fix(agent): battery-instance fallback for the dead Win32_PowerManagementEvent provider

On Windows 11 24H2/25H2 (observed on builds 26200 and 26220, session 161b838c) the MS_Power_Management_Event_Provider is still registered in the WMI repository but activating the extrinsic push query fails with WBEM_E_NOT_FOUND - the legacy provider no longer loads on exactly the OS builds new devices enroll with, so the power watcher degraded fleet-wide. Arm chain: try the push event first (still alive on older builds), then fall back to the intrinsic __InstanceModificationEvent WITHIN 30 on Win32_Battery. The WITHIN sampling runs inside WinMgmt, not in the agent; the handler path is unchanged (payload ignored, re-probe + diff), worst-case detection latency ~35s incl. debounce. collector_degraded now fires only when BOTH attempts fail; the arm log line names the active mode. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Page-Size-Option „5"
2026-10-25 05:00:07 +00:00 · 2026-08-21 15:49:03 +02:00 · 2026-08-21 15:26:03 +02:00 · 2026-08-21 15:24:41 +02:00 · 2026-08-21 14:29:08 +02:00 · 2026-08-21 14:13:46 +02:00
76 changed files with 3157 additions and 265 deletions
@@ -8,5 +8,6 @@ How the on-device agent works:
 * [Hello Wizard Un-Skip](hello-wizard-unskip.md) - why a single "WHfB disabled" policy read never decides completion: the HelloWizardStarted signal (prevention + cure) and the HelloTracker confirmation second read.
 * [Autopilot ZTD Diagnostics](autopilot-ztd-diagnostics.md) - Windows' own diagnostic surfaces for the profile-download flow: ModernDeployment event IDs (807/815/164/...), the Diagnostics\Autopilot registry key, deployment-service endpoints, and the known-issue error-code map.
 * [MDM Reboot Coalescing](mdm-reboot-coalescing.md) - attributing the mid-ESP coalesced reboot ("second sign-in") to the device-assigned policy URIs that forced it: aggregated 2800 observations (neutral, flush-time watermark) + ANALYZE-ESP-005 gated on an actually-observed reboot.
+* [Power-State Watcher](power-state-watcher.md) - live AC↔battery transitions and 50/30/15% downward threshold crossings via a WMI push subscription (no polling): power_state_change semantics (latch/debounce/cap, never armed without a battery) and the single-condition analyze rules ANALYZE-DEV-009/-010 on top.

 Reading order for newcomers: overview → decision engine → persistence.
@@ -0,0 +1,106 @@
+---
+type: Concept
+title: Power-State Watcher — live AC/battery transitions and threshold events during enrollment
+description: How the agent observes AC↔battery switches and downward battery-threshold crossings mid-enrollment via a WMI push subscription (no polling), the power_state_change event semantics (transition field, 50/30/15 ladder, latch/debounce/cap), and the two analyze rules on top (ANALYZE-DEV-009/-010).
+resource: /src/Agent/AutopilotMonitor.Agent.V2.Core/Orchestration/Hosts/PowerStateWatcherHost.cs
+tags:
+  - agent
+  - power
+  - battery
+  - collector
+  - wmi
+  - analyze-rules
+timestamp: 2026-08-21T00:00:00+02:00
+---
+
+# Power-State Watcher
+
+The startup probe (`power_state_check`, one-shot from `StartupEnvironmentProbes` via
+`PowerStateProbe`/`GetSystemPowerStatus`) only captures the power state at agent start. A
+device unplugged mid-enrollment — or draining its battery across a multi-hour ESP — was
+invisible. The watcher closes that gap **event-driven, with zero polling**.
+
+# Mechanism
+
+- `PowerStateWatcherHost` (`Orchestration/Hosts`) arms a WMI event subscription with a
+  two-step chain:
+  1. `SELECT * FROM Win32_PowerManagementEvent WHERE EventCode = 10` (PBT_APMPOWERSTATUSCHANGE:
+     true kernel push, fires on AC↔DC switches and battery-percentage steps).
+  2. **Fallback** `SELECT * FROM __InstanceModificationEvent WITHIN 30 WHERE TargetInstance
+     ISA 'Win32_Battery'` — required because on Windows 11 24H2/25H2 (observed on builds
+     26200 and 26220, session 161b838c) the `MS_Power_Management_Event_Provider` is still
+     registered in the repository but its activation fails with `WBEM_E_NOT_FOUND`: the
+     legacy push provider no longer loads on exactly the OS builds new devices enroll with.
+     The WITHIN sampling runs inside WinMgmt (one Win32_Battery snapshot every 30 s), not in
+     the agent; worst-case detection latency ≈ 35 s incl. debounce. `collector_degraded`
+     (`watcher_arm_failed`) is emitted only when BOTH attempts fail; the agent log's arm
+     line names the active mode.
+
+  Either way the arriving event's payload is ignored — each arrival re-probes via the
+  existing `PowerStateProbe.Probe()` (cheap P/Invoke).
+- Snapshots are diffed by the pure `PowerStateTransitionTracker`
+  (`Monitoring/Enrollment/SystemSignals`), which decides what to emit. The host only owns
+  WMI, a 5 s trailing-edge debounce timer (dock-flap AC→battery→AC inside the window
+  collapses to a no-diff) and the emit path (`InformationalEventPost`, single rail).
+- **No battery / probe error ⇒ WMI is never armed** — desktops and VMs pay nothing. WMI
+  arming runs on a background thread (WinMgmt can hang in OOBE; `ConsoleBypassWatcher`
+  precedent); an arm failure emits one `collector_degraded` (`watcher_arm_failed`).
+- Registered as a plain always-on peripheral host after `NetworkChangeHost`, deliberately
+  NOT under `PeriodicCollectorLifecycleHost`: it is push-based (zero idle cost) and must be
+  alive precisely when the device idles on battery. Kill-switch:
+  `Collectors.EnablePowerStateWatcher` (default true, compile-time default like the other
+  collector toggles; ConfigVersion 38).
+
+# Event: power_state_change
+
+`data.transition` discriminates three shapes (payload always carries `onAcPower`,
+`batteryPercent`, `isCharging`, `batteryLifeMinutes`; unknowns as `"unknown"`):
+
+| transition | Severity | Immediate | Notes |
+|---|---|---|---|
+| `ac_to_battery` | Warning | yes | one per accepted edge |
+| `battery_to_ac` | Info | no | recovery |
+| `threshold_crossed` | Info (50) / Warning (30) / Error (15) | 30+15 only | extra field `thresholdPercent` |
+
+Threshold semantics (tracker):
+
+- Ladder 50/30/15, evaluated only while ON battery; **each level latches once per agent
+  lifetime** (charge-up + re-drain does not re-emit — no plug-cycle alarm spam).
+- A multi-level jump emits only the LOWEST newly-crossed level (60%→10% ⇒ one `15` event).
+- Entering battery power already below a level counts as crossing it; the arm-time baseline
+  does too — an enrollment STARTING at 12% battery emits its `thresholdPercent: 15` event
+  immediately (the analyze rule would otherwise never see sessions that began low).
+- Lifetime emission cap 20 (storm backstop against a flapping dock / dying battery
+  controller); the host logs one warning when it engages.
+
+Backend/agent hygiene: `power_state_change` is classified as non-activity on both sides —
+`SignalActivityClassifier.NonActivityEventTypes` (agent: must not reset the
+PeriodicCollectorLifecycleHost/StallProbeHost idle clocks) and
+`EventIngestProcessor.IsPeriodicOrStallEvent` (backend: must not heal a Stalled session —
+battery drain is not enrollment progress).
+
+# Analyze Rules
+
+- **ANALYZE-DEV-009** (high): battery crossed 15% while on battery — matches the
+  agent-stamped `thresholdPercent equals 15`.
+- **ANALYZE-DEV-010** (warning): AC→battery switch — matches `transition equals
+  ac_to_battery`.
+- Both: `evaluateOn: ["enrollment_end", "whiteglove_sealed", "on_event:power_state_change"]`
+  (live interim finding + terminal finalization), `markSessionAsFailedDefault: false`.
+- Both are deliberately **single-required-condition**: `event_data` conditions scan events
+  independently (no same-instance join), so a two-condition rule (e.g. `transition ==
+  threshold_crossed AND batteryPercent < 15`) could false-positive across two different
+  power events. `thresholdPercent` exists only on threshold events and its value pins the
+  ladder level, so one condition fully identifies the instance.
+- `{{token}}` caveat: `AddDataFieldsToEvidence` whitelists only generic identifiers
+  (appId/errorCode/…), so `{{batteryPercent}}` would render literally. DEV-009 interpolates
+  `{{thresholdPercent}}` (the matched condition's own dataField); the exact percentage lives
+  on the linked event in the timeline.
+
+# Citations
+
+- `src/Agent/AutopilotMonitor.Agent.V2.Core/Orchestration/Hosts/PowerStateWatcherHost.cs`
+- `src/Agent/AutopilotMonitor.Agent.V2.Core/Monitoring/Enrollment/SystemSignals/PowerStateTransitionTracker.cs`
+- `src/Agent/AutopilotMonitor.Agent.V2.Core/Runtime/PowerStateProbe.cs` (probe, unchanged)
+- `rules/analyze/ANALYZE-DEV-009.json`, `rules/analyze/ANALYZE-DEV-010.json`
+- [analyze-rule-triggers](../rules/analyze-rule-triggers.md) (interim-trigger design; the WG battery rule was its motivating case)
@@ -0,0 +1,82 @@
+---
+type: concept
+title: Attempt-Scoped App Install Durations
+description: AppInstallSummary.DurationSeconds measures the status-defining (last) install attempt via a LastAttemptStartedAt max-fold anchor — replacing the first-observation-to-last-terminal span that billed multi-pass IME processing gaps to trivial apps; time attribution counts the union of active attempt segments.
+resource: src/Backend/AutopilotMonitor.Functions/Services/EventIngestProcessor.AppInstall.cs
+tags: [backend, agent, ingest, app-installs, metrics, time-attribution, durations]
+timestamp: 2026-08-21
+---
+
+# Problem
+
+The IME processes the ESP app list in multiple passes: a device-ESP evaluation pass can
+touch an app (often ending `Skipped`) long before the real install runs in a later pass.
+`AppInstallSummary` is keyed by `{SessionId}_{AppName}` and folded from ALL of the app's
+events, so `DurationSeconds = last terminal − first observation` spanned those passes.
+Field case (session `44862cd3`, "Set TimeZone"): evaluation pass 09:16, real install
+10:22:58 → 10:23:21 — reported 4002 s for a 23-second install. Fleet averages, the
+Slowest-Apps ranking, p95s, and the version-regression radar all inherited the inflation;
+the rule engine's `app_install_duration` (already attempt-scoped) contradicted the
+dashboard for the same install.
+
+# Schema
+
+Three durable anchors on the row — each with a distinct, non-interchangeable job:
+
+| Column | Fold | Role |
+|---|---|---|
+| `StartedAt` | min (earliest wins) | First observation. Server-side window/bucket filter of every AppInstallSummaries scan and the radar's version-ordering key. Never re-anchored. |
+| `LastAttemptStartedAt` | **max** (in-batch and in `ReconcileAppInstallSummaryWithExisting`) | Anchor of `DurationSeconds`. Null = sentinel (row predates 2026-08, or no start observed) → duration falls back to the historical `StartedAt` span. Replay of an older batch can never regress it. |
+| `InstallPassCount` | additive, guarded by `LastAttemptStartedAt` monotonicity (a batch whose newest start is not newer than the stored anchor adds 0) | Explains "finished long after first seen" (web ×N chip); 2+ is normal. |
+
+`DurationSeconds = CompletedAt − LastAttemptStartedAt`, computed at the terminal event and
+re-derived in one central reconcile site covering in-order and Q4 out-of-order batches.
+A `LastAttemptStartedAt` newer than `CompletedAt` means a fresh pass is in flight — the
+completed attempt's stored duration stands (the 0 value omits the column; Merge preserves).
+`DownloadDurationSeconds` pairs the latest `app_download_started` with the NEXT
+`app_install_started` (attempt-scoped, in-batch). The full span stays derivable as
+`CompletedAt − StartedAt` — deliberately not a column.
+
+Weaker-terminal guard (both in-batch and cross-batch): `app_install_completed` with
+state `Skipped`/`Postponed` never overrides an `Installed`/`Error` terminal, nor its
+`CompletedAt`/`DurationSeconds` — mirroring the long-pinned `app_install_skipped` rule.
+
+# Consumers
+
+* **Fleet metrics / apps dashboard / PDF** (`MetricsMath`, `AppsAnalyticsHelper`): values
+  drop to attempt scale; labels say "install time (final attempt)". The 6 h
+  `MaxPlausibleInstallDurationSeconds` gate remains (an attempt longer than the agent's
+  lifetime is still unobservable).
+* **AppVersionRegressionRadar**: cutover gate in `MeasuredAppGroups` — only rows with
+  `LastAttemptStartedAt` enter the duration population, on BOTH comparison sides. A mixed
+  population would mask real regressions and falsely re-arm active episodes for up to the
+  35-day horizon. `MinMeasuredInstalls` keeps it silent until enough post-cutover rows
+  exist. Thresholds (2.0× / 300 s) were tuned on span data — re-evaluate ~4 weeks after
+  rollout.
+* **Time attribution** (`TimeAttributionCalculator.BuildBlockingAppIntervals`):
+  sequence-ordered start→terminal pairing yields one segment per pass/attempt. Per-app
+  seconds = SUM of clamped segments (failed attempts and evaluation passes count — they
+  occupied the path); occupancy merges the segments, never the per-app hulls; hull
+  endpoints remain first-start→last-terminal for display and what-if. Deliberately
+  BROADER than the metrics duration: active time across all passes vs. final attempt.
+* **Agent payloads** (`AppInstallTiming` / `ImeLogTrackerAdapter.UpdateAppTiming`): a
+  terminal→active transition re-arms BOTH endpoints, so event `durationSeconds` also
+  describes the attempt (needs the agent release carrying this change).
+* **Rule engine** `app_install_duration`: was already attempt-scoped — now consistent.
+
+# Rollout
+
+No backfill (user decision, analog to the CMTrace legacy): pre-cutover rows keep span
+values, so time-series charts step down visibly at the changeover (documented in the
+public platform changelog). Sentinel-gated columns follow the standard chain:
+`BuildAppInstallSummaryEntity` + `MapToAppInstallSummary` + `AppsDashboardProjection`
+(the only projection whose consumers read the new columns).
+
+# Citations
+
+* `src/Backend/AutopilotMonitor.Functions/Services/EventIngestProcessor.AppInstall.cs` — fold + weaker-terminal guard + attempt pairing
+* `src/Backend/AutopilotMonitor.Functions/Services/TableStorageService.Metrics.cs` — reconcile max-fold, pass-count guard, central duration recompute
+* `src/Backend/AutopilotMonitor.Functions/Helpers/AppVersionRegressionRadar.cs` — cutover gate
+* `src/Backend/AutopilotMonitor.Functions/Helpers/TimeAttributionCalculator.cs` — per-pass segments + occupancy
+* `src/Agent/AutopilotMonitor.Agent.V2.Core/SignalAdapters/ImeLogTrackerAdapter.cs` — payload timing re-arm
+* Tests: `AppInstallTerminalStateAndReconcileTests`, `EventTimestampValidationTests`, `AppVersionRegressionRadarTests`, `TimeAttributionCalculatorTests`
@@ -30,6 +30,7 @@ https://docs.autopilotmonitor.com (separate repository).
 * [CMTrace Time Resolution](agent/cmtrace-time-resolution.md) - Converting bias-less CMTrace local times to UTC without trusting any process's timezone belief: per-line self-anchoring on the 15-minute offset grid for provably fresh lines, uniform marked reader-zone fallback for backlog, and the provenance vocabulary (bias / line-anchored / reader-zone-fallback) that keeps every event re-derivable.
 * [Registry App-State Second Pillar](agent/registry-app-state-pillar.md) - IME's authoritative per-app state read straight from the registry (Win32Apps EnforcementStateMessage, EspTrackingWin32Apps, StatusServiceReports) via a snapshot-and-diff watcher; registry/log reconciliation doubles as the built-in IME log-pattern drift alarm.
 * [WDP Scenario Gates & Completion Backstop](agent/wdp-scenario-gates.md) - How the agent gates Autopilot/ESP-only machinery off on Windows Device Preparation sessions (deterministic ExecutionContext marker, fail-toward-Classic), which noise it suppresses (ZTD probe, esp_config unknown, ModernDeployment 100/417/418/1005, starved sweep), and the WDP completion model: High-confidence seed, desktop-based arm D, and the 30-min device_prep_completion backstop.
+* [Power-State Watcher](agent/power-state-watcher.md) - Live AC↔battery transitions and 50/30/15% downward battery-threshold crossings during enrollment via a WMI Win32_PowerManagementEvent push subscription (zero polling, never armed on battery-less devices): the power_state_change event (transition field, per-level lifetime latch, 5s debounce, emission cap) and the analyze rules ANALYZE-DEV-009 (battery <15%, high) / ANALYZE-DEV-010 (AC→battery, warning) with on_event interim triggers.
 * [ESP Policy-Provider Stall Detection](agent/esp-policy-provider-stall.md) - The EnrollmentStatusTracking CSP's no-timeout Setup/Apps wait is keyed to the Intune-registered "Sidecar" provider by NAME: co-management's "ConfigMgr" parks the user ESP at "Apps (Identifying)" for days even with TrackingPoliciesCreated=1 (issue #106); the always-on two-arm esp_policy_provider_stalled tripwire (provider_incomplete | sidecar_provider_missing) and the SOFTWARE\Microsoft\Windows\Autopilot gather-rule allowlist entry that surface it.

 # Rules
@@ -37,6 +38,7 @@ https://docs.autopilotmonitor.com (separate repository).
 * [Gather Rule Phase Scoping, One-Shot Triggers & Emit-on-Change](rules/gather-rule-phase-scoping.md) - Restricting gather rules to enrollment phases (activePhases / activeFromPhase sticky latch), one-shot collection at a phase's start/end (phase_change / phase_exit), and emitMode "on_change" result-dedup.
 * [Gather Rule Guardrails](rules/gather-rule-guardrails.md) - Why the allowlists in rules/guardrails.json are enforced on the agent and nowhere else, which hard blocks survive unrestricted mode, and the rule that every collector must call a guard and emit security_warning on refusal.
 * [Rule Authoring Surface](rules/rule-authoring-surface.md) - How customer AIs author rules against the real contract: the baked MCP resources (guide/schemas/guardrails via combine.js), the MCP-local validate_rule pre-flight, and the side-effect-free POST rules/analyze/dryrun whose trace twin shares the production evaluators (parity + side-effect-freedom pinned by tests).
+* [Rule ID Namespace & Collision Guards](rules/rule-id-namespace.md) - Why rule identity is the human-readable ruleId (no GUIDs) with tenant isolation via Table Storage partitioning, the reserved built-in namespace (RuleIdPolicy), which collisions are possible (custom-vs-custom across tenants: allowed and harmless), and the guards keeping the global RuleStats aggregate catalog-only and the global partition inside the reserved namespace (combine.js, reseed, cross-tenant RuleState GC).
 * [Analyze Rule Evaluation Triggers](rules/analyze-rule-triggers.md) - Opt-in `evaluateOn` interim triggers (`whiteglove_sealed`, `on_event:<type>`) so rules can fire before a session is terminal, with RuleResults update-semantics (interim → finalize/resolve, NotifiedAt notification dedupe) replacing the permanent dedupe freeze, KO/stat suppression on interim runs, the ingest-side cached trigger registry, and the authoring lints that keep interim rules monotonic.

 # Backend
@@ -46,6 +48,7 @@ https://docs.autopilotmonitor.com (separate repository).
 * [OOBE Bootstrap go-Code Flow](backend/oobe-bootstrap-go-flow.md) - The bootstrap short-code lifecycle (portal-created session → `irm go.autopilotmonitor.com/CODE | iex` at Shift+F10 → GetBootstrapScriptFunction), the always-HTTP-200 text/plain contract, the two-line injection defense (GUID/URL/expiry validator + single-quoted PS literals, golden-pinned against the legacy TS template), and the per-IP rate-limit story behind Front Door.
 * [Device Journeys & First-Time-Right](backend/device-journeys.md) - How a device's terminal enrollment attempts are grouped into journeys (trim+casefold device key with junk-serial exclusion, first-success end, 30-day gap, WhiteGlove = one attempt), the DeviceHistories chain with its tombstone-driven deleted-session pruning, the additive daily FTR aggregates, and the banner/fleet/MCP surfaces.
 * [Enrollment Time Attribution](backend/time-attribution.md) - How a terminal session's authoritative wall clock (DurationSeconds, WhiteGlove pause excluded) is partitioned into named segments with an explicit unattributed remainder, ESP-blocking apps as positive evidence with "up to" what-if bounds, reboot spans from event gaps, and the breakdown/aggregate tables the sweep maintains.
+* [Attempt-Scoped App Install Durations](backend/app-install-duration-attempt.md) - AppInstallSummary.DurationSeconds = status-defining (last) install attempt via the LastAttemptStartedAt max-fold anchor instead of the first-observation→last-terminal span that billed multi-pass IME gaps to trivial apps; InstallPassCount, the weaker-terminal guard, the radar's cutover gate, and time attribution's union-of-attempt-segments occupancy.
 * [Rule Regression Radar](backend/rule-regression-radar.md) - How analyze-rule hit-rate regressions are detected (7-day window ≥2× the 28-day baseline with disjoint Wilson intervals), which suppressions keep the radar quiet (grace period, edit-in-window, kill switch), how alert episodes live in the ruleregression tracker keyspace with re-arm semantics, and the on-fire dimension correlation with its "correlated, not necessarily causal" wording contract.
 * [App Version Duration Regression Radar](backend/app-version-regression-radar.md) - How app versions whose median install duration regressed vs. the previous version are detected (first-seen-ordered versions, median lift ≥2× plus a 5-minute absolute floor over measured installs only), how alert episodes live in the appversionregression tracker keyspace with drain/median re-arm semantics, and the bell/ops-event/analytics surfaces.
 * [Tenant Activation & the Once-Only Welcome Mail](backend/tenant-activation-welcome-mail.md) - How a signup becomes an activated tenant (manual approve or the auto-approve queue), and the write-then-read + conditional-marker arbitration that sends the welcome mail exactly once even though activation and the user-typed notification address race each other.
@@ -2,6 +2,14 @@

 ## 2026-08-21

+* **New**: `agent/power-state-watcher.md` — live AC/battery observation during enrollment: `PowerStateWatcherHost` subscribes to the WMI push `Win32_PowerManagementEvent EventCode 10` (no polling; re-probes `GetSystemPowerStatus` per push, 5 s trailing-edge debounce, never armed on battery-less devices, `Collectors.EnablePowerStateWatcher` kill-switch, ConfigVersion 38). The pure `PowerStateTransitionTracker` emits `power_state_change` with `transition` = ac_to_battery (Warning, immediate) / battery_to_ac (Info) / threshold_crossed at 50/30/15% (each level latched once per lifetime, lowest-crossed-only on jumps, baseline-below-level covered, emission cap 20). Classified non-activity on both sides (SignalActivityClassifier + IsPeriodicOrStallEvent). New analyze rules ANALYZE-DEV-009 (thresholdPercent=15, high) and ANALYZE-DEV-010 (transition=ac_to_battery, warning), both with `on_event:power_state_change` interim triggers and deliberately single-required-condition (event_data conditions have no same-instance join).
+
+* **Update**: `rules/rule-id-namespace.md` — the export→paste round-trip is no longer lossy: the JSON editors now map rule-shaped exports into the form (`gatherRuleToForm` unflattens the nested gather `parameters` object, analyze `jsonToForm` maps `evaluateOn` onto the eval checkboxes; `tags` and the effective `markSessionAsFailed` carry into the created rule). Both editors still accept the serialized-form shape; edit-mode pastes merge, with an explicit `parameters`/`evaluateOn` winning over stale flat fields.
+
+* **New**: `rules/rule-id-namespace.md` — rule identity model: human-readable `ruleId` strings (no GUIDs), tenant isolation via Table Storage partitioning (`global` = built-in/community, tenantId = custom), the reserved built-in namespace from `RuleIdPolicy`, and the four collision guards: catalog-only global `RuleStats` aggregate (same-ID custom rules of unrelated tenants no longer sum into one `global_{ruleId}` row), combine.js duplicate/namespace fail, GitHub-reseed rejection of non-reserved IDs into the global partition, and the namespace gate on the cross-tenant RuleState GC.
+
+* **New**: `backend/app-install-duration-attempt.md` — attempt-scoped app install durations: `DurationSeconds` = status-defining (last) attempt anchored on the new max-folded `LastAttemptStartedAt` (StartedAt stays the earliest-wins window/version-ordering key; legacy rows without the anchor keep the span fallback); `InstallPassCount` with replay-guarded additive fold; weaker-terminal guard (completed-with-Skipped never overrides Installed/Error, in-batch and cross-batch); attempt-scoped `DownloadDurationSeconds` pairing; the version-regression radar's both-sides cutover gate; time attribution counts the union of per-pass active segments (occupancy merges segments, hulls stay for display/what-if); agent payload timing re-arms both endpoints on terminal→active. No backfill — pre-cutover rows keep span semantics.
+
 * **Update**: `agent/decision-engine.md` — activity-based RealmJoin timeout extension (report 55e6afd61c9d: a large RJ package catalog outlived the 60-min window mid-install — the timer arms at RJ-agent-MSI detection, so the first deployment had effectively ~44 min). When the `RealmJoinTimeout` deadline fires with `LastDeploymentPhase` 100/101 and deployment activity (phase change or package observation, persisted in `RealmJoinFacts.LastActivityUtc`; the detection-time phase capture deliberately excluded) inside the last 60 min, the deadline re-arms to `lastActivity + 60 min` (Info event `realmjoin_timeout_extended`), clamped at detection + 4 h. `realmjoin_timeout` now carries `reason` = `hard_timeout` / `inactivity` / `absolute_cap`; a fire of a superseded deadline incarnation dead-ends. Idle detection and phase-200/210 sessions keep the original 60-min behavior.

 * **New**: `backend/send-time-frame-separation.md` — P14: the agent stamps one device-clock send timestamp per upload attempt (`X-Send-Time-Utc`), the ingest function server-stamps it as `SentAt` on every event of the request. `SentAt − OccurredUtc` is pure spool delay, `ReceivedAt − SentAt` is network + device-vs-server clock offset — the two were indistinguishable before and had to be separated statistically. The `clock_skew` condition measures SentAt-carrying batches directly (spool-immune, no spread cap, IME-only sessions become measurable; evidence carries `sentAtBatchCount`), legacy batches keep the median path; the CMTrace tripwire deliberately stays on its differential math (common-mode clock offset cancels there).
@@ -98,7 +98,7 @@ Interim evaluation changes what a rule's conditions mean mid-flight. Three new l

 # Application to the Motivating Cases

- WG battery rule (sits-d): `evaluateOn: ["enrollment_end", "whiteglove_sealed"]` — technician gets the channel alert at the bench; Part-2 terminal pass finalizes or resolves the finding.
+- WG battery rule (sits-d): shipped 2026-08-21 as ANALYZE-DEV-009 (battery below 15% while on battery) and ANALYZE-DEV-010 (AC→battery switch), both `evaluateOn: ["enrollment_end", "whiteglove_sealed", "on_event:power_state_change"]` on the live power watcher's `power_state_change` events (see `../agent/power-state-watcher.md`) — technician gets the channel alert at the bench; the terminal pass finalizes the finding. Both are deliberately single-required-condition rules: `event_data` conditions scan events independently (no same-instance join), so DEV-009 matches the agent-stamped `thresholdPercent` and DEV-010 matches `transition`.
 - Hybrid-affinity stuck (esa): ANALYZE-ID-004 gets `evaluateOn: ["enrollment_end", "on_event:hybrid_login_pending"]` — the second overdue-login event (threshold 65) produces a live finding on the still-InProgress session. ANALYZE-APP-015 stays `enrollment_end`-only until its conditions are hardened (lint 1).

 - Stuck after a forced mid-ESP reboot (sits-d Cloud PCs, 2026-08-19): `on_event:session_stalled` is the established trigger for the never-terminal stuck session. The agent emits `session_stalled` exactly once per session (60-minute stall probe), so the trigger is rare by construction and needs no throttle. Five Cloud PCs sat at `InProgress` with **zero findings** for hours — a mid-ESP reboot had killed the agent in `Stage=EspAccountSetup` — before the max-lifetime watchdog eventually terminalised them as `Incomplete`. ANALYZE-ESP-005 carries the trigger and fires on that stream at confidence 95 (verified against session `8110e262`): both its conditions (`mdm_policy_reboot_required.firstRebootUri` exists, `system_reboot_detected` count ≥ 1) are **monotonic** and it has no terminal preconditions, so lint 1 does not apply. ANALYZE-APP-016 is interim-safe for the same reason (`app_install_starved` count ≥ 1 only ever grows).
@@ -0,0 +1,47 @@
+---
+type: concept
+title: Rule ID Namespace & Collision Guards
+description: How gather/analyze rule identity is scoped (tenant partition vs global partition), why there are no GUIDs, which collisions are possible, and the guards that keep the reserved built-in namespace and the global RuleStats aggregate clean.
+resource: backend, rules
+tags: [rules, ruleid, namespace, collision, rulestats, tenant-isolation]
+timestamp: 2026-08-21
+---
+
+# Schema
+
+Rule identity is the human-readable `ruleId` string — there are no GUIDs, deliberately: the ID appears in logs, mails, notifications, RuleResults, the agent config payload, and docs, and tenant isolation is provided by Table Storage partitioning instead.
+
+| Store | PartitionKey | RowKey | Content |
+|---|---|---|---|
+| `GatherRules` / `AnalyzeRules` | `"global"` | ruleId | Built-in + community rules (shared, all tenants) |
+| `GatherRules` / `AnalyzeRules` | tenantId | ruleId | Custom rules (visible only to that tenant) |
+| `RuleStates` | tenantId | ruleId | Per-tenant enable/notify overrides — built-in/community rules ONLY (custom rules fold state into their own row) |
+| `RuleStats` | date | `{tenantId}_{ruleId}` and `global_{ruleId}` | Daily fire/eval telemetry; the global row is catalog-only (see guards) |
+
+Namespace split (`RuleIdPolicy.cs`, shared model):
+
+- **Reserved built-in namespace**: `(ANALYZE|GATHER)-<CATEGORY>-<NUMBER>` with `CATEGORY != CUSTOM`, case-insensitive, including currently unused numbers (gaps = retired rules that may return).
+- **Tenant namespace**: everything else — `ANALYZE-CUSTOM-NNN` (portal suggestion), `-CUSTOM` suffixes, org prefixes (`CONTOSO-WIFI-001`), freeform.
+
+# Collision model
+
+- **Custom vs built-in**: impossible via API — `CreateRuleAsync`/`UpdateRuleAsync` reject reserved IDs (409) and check existence against `global` ∪ own tenant partition. Legacy debris is neutralized at merge time: global wins, tenant copy dropped with a warning (pinned by `RuleMergeCollisionGuardTests`, motivated by the 5ca2b350 duplicate-key incident).
+- **Custom vs custom across tenants**: allowed and harmless — separate partitions, separate evaluation, separate RuleResults/tenant stats. Two tenants both using `ANALYZE-CUSTOM-101` never interact.
+- **JSON copy between tenants** (export → paste into create editor): goes through the same create path, so an ID already taken in the receiving tenant surfaces as 409 — the user renames. There is no bulk import endpoint. The JSON editors accept both shapes — a rule export and the serialized form — via `gatherRuleToForm` / `jsonToForm` (web `types.ts` of each rules page): nested gather `parameters` are unflattened, analyze `evaluateOn` maps onto the eval checkboxes, and `tags` plus the effective `markSessionAsFailed` survive the import.
+
+# Guards (all enforced, 2026-08-21)
+
+1. **Global RuleStats aggregate is catalog-only.** The `global_{ruleId}` row would otherwise sum same-ID custom rules of unrelated tenants (title/severity last-writer-wins). Analyze gates on `rule.IsBuiltIn || rule.IsCommunity` (`AnalyzeOnEnrollmentEndHandler`), gather gates on `RuleIdPolicy.IsReservedBuiltInId` (`EventIngestProcessor.RuleStats`) because agent events carry no flag — valid because custom rules can never occupy the reserved pattern.
+2. **Catalog build fails on namespace violations.** `rules/scripts/combine.js` rejects duplicate IDs (case-insensitive) and any gather/analyze built-in outside the reserved pattern; `BuiltInRuleCatalogPolicyTests` pins the same invariants on the embedded resource actually deployed.
+3. **GitHub reseed rejects non-reserved IDs** before writing to the `global` partition (`ReseedFromGitHubFunction`) — a seeded `*-CUSTOM-*` rule would silently shadow every tenant's same-ID custom rule at merge time.
+4. **Cross-tenant RuleState GC is namespace-gated.** `DeleteRuleStatesForRuleIdAcrossTenantsAsync` deletes by bare RowKey across all partitions; it now refuses non-reserved IDs with `failed=-1` (callers then skip the global catalog delete, same contract as enumeration failure).
+
+Invariant chain: schema pattern + combine.js + reseed guard ⇒ the `global` partition only ever contains reserved-pattern IDs ⇒ the pattern is a safe built-in/custom discriminator everywhere no `IsBuiltIn` flag is available.
+
+# Citations
+
+- `src/Shared/AutopilotMonitor.Shared/Models/Rules/RuleIdPolicy.cs` — reserved pattern + rationale
+- `src/Backend/AutopilotMonitor.Functions/Services/AnalyzeRuleService.cs`, `GatherRuleService.cs` — create/update guards, merge collision guard
+- `src/Backend/AutopilotMonitor.Functions/Services/TableStorageService.Rules.cs` — key schemes, cross-tenant GC guard
+- `src/Backend/AutopilotMonitor.Functions.Tests/BuiltInRuleCatalogPolicyTests.cs`, `RuleIdReservationTests.cs`, `RuleMergeCollisionGuardTests.cs`
+- `rules/scripts/combine.js` — build-time namespace/duplicate guard
@@ -0,0 +1,48 @@
+{
+  "$schema": "../schema/analyze-rule.schema.json",
+  "ruleId": "ANALYZE-DEV-009",
+  "title": "Battery Critically Low During Enrollment",
+  "description": "Detects that the device's battery dropped to 15% or less while enrolling on battery power (power_state_change threshold event from the agent's live power watcher). A device dying mid-enrollment leaves a half-provisioned state that typically needs a full reset; this rule surfaces the risk while there is still time to plug the device in. Uses a single required condition on the agent-stamped thresholdPercent field (the data field 'transition' on the event is unrelated to this rule's 'trigger' property).",
+  "severity": "high",
+  "category": "device",
+  "version": "1.0.0",
+  "enabled": true,
+  "evaluateOn": [
+    "enrollment_end",
+    "whiteglove_sealed",
+    "on_event:power_state_change"
+  ],
+  "trigger": "single",
+  "baseConfidence": 90,
+  "confidenceThreshold": 60,
+  "conditions": [
+    {
+      "signal": "battery_threshold_15",
+      "source": "event_data",
+      "eventType": "power_state_change",
+      "dataField": "thresholdPercent",
+      "operator": "equals",
+      "value": "15",
+      "required": true
+    }
+  ],
+  "explanation": "The device's battery fell below **{{thresholdPercent}}%** while the enrollment was running on battery power. If the battery drains completely mid-enrollment, the device is left in a half-provisioned state — apps, policies, or the user profile may be incomplete, and in most cases the device has to be reset and re-enrolled. The agent detected the threshold crossing live via a Windows power-status notification; the exact percentage at that moment is recorded on the matched power_state_change event in the session timeline.",
+  "remediation": [
+    {
+      "title": "Secure power for the running enrollment",
+      "steps": [
+        "Connect the device to AC power immediately — the enrollment continues normally once power is stable.",
+        "If the device shut down before completing, check whether the session reached the desktop; if not, reset the device (Autopilot reset or reimage) and re-enroll it plugged in.",
+        "For technician/White Glove flows, make AC power part of the bench checklist — pre-provisioning on battery is the most common source of this alert.",
+        "If this fires across many devices of one model, review that model's battery health (the hardware_spec event carries design vs. full-charge capacity)."
+      ]
+    }
+  ],
+  "markSessionAsFailedDefault": false,
+  "tags": [
+    "device",
+    "power",
+    "battery",
+    "environment"
+  ]
+}
@@ -0,0 +1,48 @@
+{
+  "$schema": "../schema/analyze-rule.schema.json",
+  "ruleId": "ANALYZE-DEV-010",
+  "title": "Enrollment Switched From AC to Battery Power",
+  "description": "Detects that the device lost AC power and switched to battery while the enrollment was running (power_state_change event with transition ac_to_battery from the agent's live power watcher). Uses a single required condition so the match is pinned to one event instance; the event payload carries the battery percentage at the moment of the switch. The agent debounces power flapping (5s) so a brief unplug/replug does not produce this event.",
+  "severity": "warning",
+  "category": "device",
+  "version": "1.0.0",
+  "enabled": true,
+  "evaluateOn": [
+    "enrollment_end",
+    "whiteglove_sealed",
+    "on_event:power_state_change"
+  ],
+  "trigger": "single",
+  "baseConfidence": 85,
+  "confidenceThreshold": 60,
+  "conditions": [
+    {
+      "signal": "switched_to_battery",
+      "source": "event_data",
+      "eventType": "power_state_change",
+      "dataField": "transition",
+      "operator": "equals",
+      "value": "ac_to_battery",
+      "required": true
+    }
+  ],
+  "explanation": "The device switched from AC to battery power mid-enrollment. Enrollments are power-hungry — app downloads, Windows Update and disk encryption drain a battery quickly, and Windows may also throttle CPU and network on battery, slowing the enrollment down. The battery percentage at the moment of the switch is recorded on the matched power_state_change event in the session timeline; if the device stayed on battery, look there for subsequent threshold events (50/30/15%) — a later battery_to_ac event means power was restored.",
+  "remediation": [
+    {
+      "title": "Restore AC power",
+      "steps": [
+        "Reconnect the device to AC power; the enrollment continues normally.",
+        "Check the session timeline for a subsequent battery_to_ac event (power restored) or threshold_crossed events (battery draining) to judge urgency.",
+        "If this alert is frequent in a deployment area, check docking stations/USB-C hubs for loose power delivery — a flapping dock is a common cause.",
+        "Make 'plugged in during setup' part of the end-user/technician enrollment instructions."
+      ]
+    }
+  ],
+  "markSessionAsFailedDefault": false,
+  "tags": [
+    "device",
+    "power",
+    "battery",
+    "environment"
+  ]
+}
@@ -1584,6 +1584,100 @@
        "known-issue"
      ]
    },
+    {
+      "ruleId": "ANALYZE-DEV-009",
+      "title": "Battery Critically Low During Enrollment",
+      "description": "Detects that the device's battery dropped to 15% or less while enrolling on battery power (power_state_change threshold event from the agent's live power watcher). A device dying mid-enrollment leaves a half-provisioned state that typically needs a full reset; this rule surfaces the risk while there is still time to plug the device in. Uses a single required condition on the agent-stamped thresholdPercent field (the data field 'transition' on the event is unrelated to this rule's 'trigger' property).",
+      "severity": "high",
+      "category": "device",
+      "version": "1.0.0",
+      "enabled": true,
+      "evaluateOn": [
+        "enrollment_end",
+        "whiteglove_sealed",
+        "on_event:power_state_change"
+      ],
+      "trigger": "single",
+      "baseConfidence": 90,
+      "confidenceThreshold": 60,
+      "conditions": [
+        {
+          "signal": "battery_threshold_15",
+          "source": "event_data",
+          "eventType": "power_state_change",
+          "dataField": "thresholdPercent",
+          "operator": "equals",
+          "value": "15",
+          "required": true
+        }
+      ],
+      "explanation": "The device's battery fell below **{{thresholdPercent}}%** while the enrollment was running on battery power. If the battery drains completely mid-enrollment, the device is left in a half-provisioned state — apps, policies, or the user profile may be incomplete, and in most cases the device has to be reset and re-enrolled. The agent detected the threshold crossing live via a Windows power-status notification; the exact percentage at that moment is recorded on the matched power_state_change event in the session timeline.",
+      "remediation": [
+        {
+          "title": "Secure power for the running enrollment",
+          "steps": [
+            "Connect the device to AC power immediately — the enrollment continues normally once power is stable.",
+            "If the device shut down before completing, check whether the session reached the desktop; if not, reset the device (Autopilot reset or reimage) and re-enroll it plugged in.",
+            "For technician/White Glove flows, make AC power part of the bench checklist — pre-provisioning on battery is the most common source of this alert.",
+            "If this fires across many devices of one model, review that model's battery health (the hardware_spec event carries design vs. full-charge capacity)."
+          ]
+        }
+      ],
+      "markSessionAsFailedDefault": false,
+      "tags": [
+        "device",
+        "power",
+        "battery",
+        "environment"
+      ]
+    },
+    {
+      "ruleId": "ANALYZE-DEV-010",
+      "title": "Enrollment Switched From AC to Battery Power",
+      "description": "Detects that the device lost AC power and switched to battery while the enrollment was running (power_state_change event with transition ac_to_battery from the agent's live power watcher). Uses a single required condition so the match is pinned to one event instance; the event payload carries the battery percentage at the moment of the switch. The agent debounces power flapping (5s) so a brief unplug/replug does not produce this event.",
+      "severity": "warning",
+      "category": "device",
+      "version": "1.0.0",
+      "enabled": true,
+      "evaluateOn": [
+        "enrollment_end",
+        "whiteglove_sealed",
+        "on_event:power_state_change"
+      ],
+      "trigger": "single",
+      "baseConfidence": 85,
+      "confidenceThreshold": 60,
+      "conditions": [
+        {
+          "signal": "switched_to_battery",
+          "source": "event_data",
+          "eventType": "power_state_change",
+          "dataField": "transition",
+          "operator": "equals",
+          "value": "ac_to_battery",
+          "required": true
+        }
+      ],
+      "explanation": "The device switched from AC to battery power mid-enrollment. Enrollments are power-hungry — app downloads, Windows Update and disk encryption drain a battery quickly, and Windows may also throttle CPU and network on battery, slowing the enrollment down. The battery percentage at the moment of the switch is recorded on the matched power_state_change event in the session timeline; if the device stayed on battery, look there for subsequent threshold events (50/30/15%) — a later battery_to_ac event means power was restored.",
+      "remediation": [
+        {
+          "title": "Restore AC power",
+          "steps": [
+            "Reconnect the device to AC power; the enrollment continues normally.",
+            "Check the session timeline for a subsequent battery_to_ac event (power restored) or threshold_crossed events (battery draining) to judge urgency.",
+            "If this alert is frequent in a deployment area, check docking stations/USB-C hubs for loose power delivery — a flapping dock is a common cause.",
+            "Make 'plugged in during setup' part of the end-user/technician enrollment instructions."
+          ]
+        }
+      ],
+      "markSessionAsFailedDefault": false,
+      "tags": [
+        "device",
+        "power",
+        "battery",
+        "environment"
+      ]
+    },
    {
      "ruleId": "ANALYZE-ENRL-001",
      "title": "Enrollment Failed",
@@ -13,18 +13,26 @@ const rulesRoot = path.resolve(__dirname, '..');

 // ── Rule combination ────────────────────────────────────────────────────────

+// Shipped gather/analyze rules must stay inside the reserved built-in namespace:
+// (ANALYZE|GATHER)-<CATEGORY>-<NNN> with CATEGORY !== CUSTOM. The CUSTOM category is
+// the sanctioned tenant namespace (RuleIdPolicy.cs) — a built-in shipped there would
+// silently shadow every tenant's same-ID custom rule at merge time (global wins).
+const RESERVED_BUILTIN_ID = /^(ANALYZE|GATHER)-(?!CUSTOM-)[A-Z]+-\d{3}$/;
+
 const configs = [
  {
    dir: path.join(rulesRoot, 'gather'),
    output: path.join(rulesRoot, 'dist', 'gather-rules.json'),
    schema: '../schema/gather-rule.schema.json',
-    idField: 'ruleId'
+    idField: 'ruleId',
+    reservedNamespace: RESERVED_BUILTIN_ID
  },
  {
    dir: path.join(rulesRoot, 'analyze'),
    output: path.join(rulesRoot, 'dist', 'analyze-rules.json'),
    schema: '../schema/analyze-rule.schema.json',
-    idField: 'ruleId'
+    idField: 'ruleId',
+    reservedNamespace: RESERVED_BUILTIN_ID
  },
  {
    dir: path.join(rulesRoot, 'ime-log-patterns'),
@@ -37,12 +45,27 @@ const configs = [
 for (const config of configs) {
  const files = fs.readdirSync(config.dir).filter(f => f.endsWith('.json')).sort();
  const rules = [];
+  const seenIds = new Map(); // lowercased id -> filename (case variants collide for humans and RuleIdPolicy)

  for (const file of files) {
    const content = fs.readFileSync(path.join(config.dir, file), 'utf8');
    const rule = JSON.parse(content);
    // Remove $schema from individual entries (it's on the wrapper)
    delete rule['$schema'];
+
+    const id = rule[config.idField] || '';
+    const idKey = id.toLowerCase();
+    if (seenIds.has(idKey)) {
+      console.error(`ERROR: duplicate ${config.idField} "${id}" in ${file} (already defined in ${seenIds.get(idKey)})`);
+      process.exit(1);
+    }
+    seenIds.set(idKey, file);
+
+    if (config.reservedNamespace && !config.reservedNamespace.test(id)) {
+      console.error(`ERROR: ${file}: ${config.idField} "${id}" is outside the reserved built-in namespace ${config.reservedNamespace} — built-ins must never use the tenant CUSTOM namespace`);
+      process.exit(1);
+    }
+
    rules.push(rule);
  }

@@ -0,0 +1,258 @@
+#nullable enable
+using AutopilotMonitor.Agent.V2.Core.Monitoring.Enrollment.SystemSignals;
+using AutopilotMonitor.Agent.V2.Core.Runtime;
+using AutopilotMonitor.Shared.Models;
+using Xunit;
+
+namespace AutopilotMonitor.Agent.V2.Core.Tests.Monitoring.SystemSignals
+{
+    /// <summary>
+    /// Pure state machine behind the power watcher: AC↔battery edges, the 50/30/15 threshold
+    /// ladder (latch once per lifetime, lowest-crossed-only on multi-level jumps, baseline
+    /// coverage for sessions starting low), null-percent tolerance and the storm cap.
+    /// </summary>
+    public sealed class PowerStateTransitionTrackerTests
+    {
+        private static PowerStateResult Ac(int? percent = 80, bool charging = true) => new PowerStateResult
+        {
+            OnAcPower = true,
+            HasBattery = true,
+            BatteryPercent = percent,
+            IsCharging = charging,
+            BatteryLifeMinutes = null,
+        };
+
+        private static PowerStateResult Battery(int? percent, int? lifeMinutes = 90) => new PowerStateResult
+        {
+            OnAcPower = false,
+            HasBattery = true,
+            BatteryPercent = percent,
+            IsCharging = false,
+            BatteryLifeMinutes = lifeMinutes,
+        };
+
+        [Fact]
+        public void Baseline_on_ac_is_silent()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            Assert.Empty(tracker.Baseline(Ac()));
+        }
+
+        [Fact]
+        public void Baseline_without_battery_or_with_probe_error_is_silent()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            Assert.Empty(tracker.Baseline(new PowerStateResult { OnAcPower = true, HasBattery = false }));
+            Assert.Empty(tracker.Baseline(new PowerStateResult { ProbeError = "boom" }));
+        }
+
+        [Fact]
+        public void Baseline_on_battery_above_ladder_is_silent()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            Assert.Empty(tracker.Baseline(Battery(80)));
+        }
+
+        [Fact]
+        public void Baseline_at_12_percent_emits_exactly_the_15_threshold()
+        {
+            var tracker = new PowerStateTransitionTracker();
+
+            var emissions = tracker.Baseline(Battery(12));
+
+            var e = Assert.Single(emissions);
+            Assert.Equal(PowerStateTransitionTracker.TransitionThresholdCrossed, e.Transition);
+            Assert.Equal(15, e.ThresholdPercent);
+            Assert.Equal(12, e.BatteryPercent);
+            Assert.Equal(EventSeverity.Error, e.Severity);
+            Assert.True(e.ImmediateUpload);
+        }
+
+        [Fact]
+        public void Baseline_at_25_percent_emits_30_and_latches_50()
+        {
+            var tracker = new PowerStateTransitionTracker();
+
+            var baseline = tracker.Baseline(Battery(25));
+            var e = Assert.Single(baseline);
+            Assert.Equal(30, e.ThresholdPercent);
+            Assert.Equal(EventSeverity.Warning, e.Severity);
+            Assert.True(e.ImmediateUpload);
+
+            // 50 and 30 are latched by the baseline; draining to 40% stays silent, 14% emits 15.
+            Assert.Empty(tracker.Evaluate(Battery(40)));
+            var next = Assert.Single(tracker.Evaluate(Battery(14)));
+            Assert.Equal(15, next.ThresholdPercent);
+        }
+
+        [Fact]
+        public void Ac_to_battery_emits_warning_with_immediate_upload()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac(63));
+
+            var e = Assert.Single(tracker.Evaluate(Battery(63)));
+
+            Assert.Equal(PowerStateTransitionTracker.TransitionAcToBattery, e.Transition);
+            Assert.Null(e.ThresholdPercent);
+            Assert.Equal(EventSeverity.Warning, e.Severity);
+            Assert.True(e.ImmediateUpload);
+            Assert.False(e.OnAcPower);
+            Assert.Equal(63, e.BatteryPercent);
+        }
+
+        [Fact]
+        public void Battery_to_ac_emits_info_without_immediate_upload()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Battery(70));
+
+            var e = Assert.Single(tracker.Evaluate(Ac(70)));
+
+            Assert.Equal(PowerStateTransitionTracker.TransitionBatteryToAc, e.Transition);
+            Assert.Equal(EventSeverity.Info, e.Severity);
+            Assert.False(e.ImmediateUpload);
+        }
+
+        [Fact]
+        public void No_diff_stays_silent()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac());
+
+            Assert.Empty(tracker.Evaluate(Ac()));
+            Assert.Empty(tracker.Evaluate(Ac(79)));
+        }
+
+        [Fact]
+        public void Unplug_below_threshold_emits_transition_and_threshold_together()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac(10));
+
+            var emissions = tracker.Evaluate(Battery(10));
+
+            Assert.Equal(2, emissions.Count);
+            Assert.Equal(PowerStateTransitionTracker.TransitionAcToBattery, emissions[0].Transition);
+            Assert.Equal(PowerStateTransitionTracker.TransitionThresholdCrossed, emissions[1].Transition);
+            Assert.Equal(15, emissions[1].ThresholdPercent);
+        }
+
+        [Fact]
+        public void Multi_level_drop_emits_lowest_crossed_level_only()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Battery(60));
+
+            var e = Assert.Single(tracker.Evaluate(Battery(10)));
+
+            Assert.Equal(15, e.ThresholdPercent);
+            // All levels are latched — recovering and re-draining emits nothing more.
+            tracker.Evaluate(Ac(90));
+            Assert.Single(tracker.Evaluate(Battery(45)), x => x.Transition == PowerStateTransitionTracker.TransitionAcToBattery);
+            Assert.Empty(tracker.Evaluate(Battery(13)));
+        }
+
+        [Fact]
+        public void Each_level_latches_once_per_lifetime()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Battery(70));
+
+            Assert.Single(tracker.Evaluate(Battery(48))); // 50
+            Assert.Empty(tracker.Evaluate(Battery(47)));  // still inside 50, no re-emit
+            Assert.Single(tracker.Evaluate(Battery(29))); // 30
+            Assert.Single(tracker.Evaluate(Battery(15))); // 15 (boundary: <= level)
+            Assert.Empty(tracker.Evaluate(Battery(5)));   // ladder exhausted
+        }
+
+        [Fact]
+        public void Threshold_severity_ladder_is_info_warning_error()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Battery(70));
+
+            var fifty = Assert.Single(tracker.Evaluate(Battery(50)));
+            Assert.Equal(EventSeverity.Info, fifty.Severity);
+            Assert.False(fifty.ImmediateUpload);
+
+            var thirty = Assert.Single(tracker.Evaluate(Battery(30)));
+            Assert.Equal(EventSeverity.Warning, thirty.Severity);
+            Assert.True(thirty.ImmediateUpload);
+
+            var fifteen = Assert.Single(tracker.Evaluate(Battery(15)));
+            Assert.Equal(EventSeverity.Error, fifteen.Severity);
+            Assert.True(fifteen.ImmediateUpload);
+        }
+
+        [Fact]
+        public void Null_battery_percent_skips_thresholds_but_ac_diff_still_works()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac(null));
+
+            var e = Assert.Single(tracker.Evaluate(Battery(null, lifeMinutes: null)));
+
+            Assert.Equal(PowerStateTransitionTracker.TransitionAcToBattery, e.Transition);
+            Assert.Null(e.BatteryPercent);
+            Assert.Contains("battery level unknown", e.Message);
+            Assert.Empty(tracker.Evaluate(Battery(null, lifeMinutes: null)));
+        }
+
+        [Fact]
+        public void Probe_error_mid_run_preserves_state()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac());
+
+            Assert.Empty(tracker.Evaluate(new PowerStateResult { ProbeError = "transient" }));
+            // State was not corrupted by the error — the real transition still diffs cleanly.
+            Assert.Single(tracker.Evaluate(Battery(60)));
+        }
+
+        [Fact]
+        public void Evaluate_without_baseline_latches_like_a_baseline()
+        {
+            var tracker = new PowerStateTransitionTracker();
+
+            var e = Assert.Single(tracker.Evaluate(Battery(12)));
+
+            // No phantom ac_to_battery from the implicit default state — only the threshold.
+            Assert.Equal(PowerStateTransitionTracker.TransitionThresholdCrossed, e.Transition);
+        }
+
+        [Fact]
+        public void Emission_cap_suppresses_and_flips_flag_once()
+        {
+            var tracker = new PowerStateTransitionTracker(maxEmissions: 4);
+            tracker.Baseline(Ac());
+
+            // Flapping power source: each edge is one emission.
+            for (var i = 0; i < 2; i++)
+            {
+                Assert.Single(tracker.Evaluate(Battery(80)));
+                Assert.Single(tracker.Evaluate(Ac(80)));
+            }
+            Assert.False(tracker.EmissionCapReached);
+
+            Assert.Empty(tracker.Evaluate(Battery(80)));
+            Assert.True(tracker.EmissionCapReached);
+            Assert.Empty(tracker.Evaluate(Ac(80)));
+        }
+
+        [Fact]
+        public void Message_carries_percent_and_transition_context()
+        {
+            var tracker = new PowerStateTransitionTracker();
+            tracker.Baseline(Ac(62));
+
+            var toBattery = Assert.Single(tracker.Evaluate(Battery(62)));
+            Assert.Contains("AC to battery", toBattery.Message);
+            Assert.Contains("battery 62%", toBattery.Message);
+
+            var backToAc = Assert.Single(tracker.Evaluate(Ac(63)));
+            Assert.Contains("back to AC", backToAc.Message);
+            Assert.Contains("charging", backToAc.Message);
+        }
+    }
+}
@@ -0,0 +1,162 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AutopilotMonitor.Agent.V2.Core.Logging;
+using AutopilotMonitor.Agent.V2.Core.Orchestration;
+using AutopilotMonitor.Agent.V2.Core.Runtime;
+using AutopilotMonitor.Agent.V2.Core.Tests.Harness;
+using AutopilotMonitor.DecisionCore.Engine;
+using AutopilotMonitor.DecisionCore.Signals;
+using AutopilotMonitor.Shared;
+using Xunit;
+
+namespace AutopilotMonitor.Agent.V2.Core.Tests.Orchestration
+{
+    /// <summary>
+    /// PowerStateWatcherHost — no-battery/probe-error devices never arm, a low-battery baseline
+    /// emits its threshold event onto the single rail, and debounced ticks translate tracker
+    /// emissions into <c>power_state_change</c> events. WMI arming itself stays untested
+    /// (ConsoleBypassWatcher precedent); <c>StartCore(armWmi: false)</c> exercises everything else.
+    /// </summary>
+    public sealed class PowerStateWatcherHostTests : IDisposable
+    {
+        private static readonly DateTime At = new DateTime(2026, 8, 21, 9, 0, 0, DateTimeKind.Utc);
+
+        private readonly TempDirectory _tmp = new TempDirectory();
+        private readonly FakeSignalIngressSink _sink = new FakeSignalIngressSink();
+        private readonly AgentLogger _logger;
+        private PowerStateResult _probeResult = new PowerStateResult { OnAcPower = true, HasBattery = true, BatteryPercent = 80 };
+
+        public PowerStateWatcherHostTests()
+        {
+            _logger = new AgentLogger(_tmp.Path, AgentLogLevel.Info);
+        }
+
+        public void Dispose() => _tmp.Dispose();
+
+        private PowerStateWatcherHost Build() => new PowerStateWatcherHost(
+            sessionId: "sess-power",
+            tenantId: "tenant-power",
+            ingress: _sink,
+            clock: new VirtualClock(At),
+            logger: _logger,
+            probe: () => _probeResult);
+
+        private IReadOnlyList<FakeSignalIngressSink.PostedSignal> PowerEvents() =>
+            _sink.Posted.Where(p =>
+                p.Kind == DecisionSignalKind.InformationalEvent
+                && p.Payload != null
+                && p.Payload.TryGetValue(SignalPayloadKeys.EventType, out var et)
+                && et == Constants.EventTypes.PowerStateChange).ToList();
+
+        [Fact]
+        public void No_battery_emits_nothing()
+        {
+            _probeResult = new PowerStateResult { OnAcPower = true, HasBattery = false };
+
+            Build().StartCore(armWmi: false);
+
+            Assert.Empty(_sink.Posted);
+        }
+
+        [Fact]
+        public void Probe_error_emits_nothing()
+        {
+            _probeResult = new PowerStateResult { ProbeError = "GetSystemPowerStatus returned false" };
+
+            Build().StartCore(armWmi: false);
+
+            Assert.Empty(_sink.Posted);
+        }
+
+        [Fact]
+        public void Baseline_below_threshold_emits_threshold_event_with_immediate_upload()
+        {
+            _probeResult = new PowerStateResult { OnAcPower = false, HasBattery = true, BatteryPercent = 12, BatteryLifeMinutes = 34 };
+
+            Build().StartCore(armWmi: false);
+
+            var s = Assert.Single(PowerEvents());
+            Assert.Equal("Error", s.Payload![SignalPayloadKeys.Severity]);
+            Assert.Equal("true", s.Payload![SignalPayloadKeys.ImmediateUpload]);
+            Assert.Contains("15%", s.Payload![SignalPayloadKeys.Message]);
+
+            var data = (IReadOnlyDictionary<string, object>)s.TypedPayload!;
+            Assert.Equal("threshold_crossed", data["transition"]);
+            Assert.Equal(15, data["thresholdPercent"]);
+            Assert.Equal(12, data["batteryPercent"]);
+            Assert.Equal(false, data["onAcPower"]);
+            Assert.Equal(34, data["batteryLifeMinutes"]);
+        }
+
+        [Fact]
+        public void Tick_after_unplug_emits_ac_to_battery_warning()
+        {
+            var host = Build();
+            host.StartCore(armWmi: false);
+            Assert.Empty(PowerEvents());
+
+            _probeResult = new PowerStateResult { OnAcPower = false, HasBattery = true, BatteryPercent = 79 };
+            host.TickForTest();
+
+            var s = Assert.Single(PowerEvents());
+            Assert.Equal("Warning", s.Payload![SignalPayloadKeys.Severity]);
+            Assert.Equal("true", s.Payload![SignalPayloadKeys.ImmediateUpload]);
+
+            var data = (IReadOnlyDictionary<string, object>)s.TypedPayload!;
+            Assert.Equal("ac_to_battery", data["transition"]);
+            Assert.Equal(79, data["batteryPercent"]);
+            Assert.False(data.ContainsKey("thresholdPercent"));
+
+            // Replug: Info recovery event without immediate upload.
+            _probeResult = new PowerStateResult { OnAcPower = true, HasBattery = true, BatteryPercent = 79, IsCharging = true };
+            host.TickForTest();
+
+            Assert.Equal(2, PowerEvents().Count);
+            var back = PowerEvents()[1];
+            Assert.Equal("Info", back.Payload![SignalPayloadKeys.Severity]);
+            Assert.Equal("false", back.Payload![SignalPayloadKeys.ImmediateUpload]);
+            Assert.Equal("battery_to_ac", ((IReadOnlyDictionary<string, object>)back.TypedPayload!)["transition"]);
+        }
+
+        [Fact]
+        public void Tick_with_unchanged_state_emits_nothing()
+        {
+            var host = Build();
+            host.StartCore(armWmi: false);
+
+            host.TickForTest();
+            host.TickForTest();
+
+            Assert.Empty(PowerEvents());
+        }
+
+        [Fact]
+        public void Stopped_host_ignores_ticks()
+        {
+            var host = Build();
+            host.StartCore(armWmi: false);
+            host.Stop();
+
+            _probeResult = new PowerStateResult { OnAcPower = false, HasBattery = true, BatteryPercent = 50 };
+            host.TickForTest();
+
+            Assert.Empty(PowerEvents());
+        }
+
+        [Fact]
+        public void Unknown_battery_percent_serializes_as_unknown()
+        {
+            var host = Build();
+            host.StartCore(armWmi: false);
+
+            _probeResult = new PowerStateResult { OnAcPower = false, HasBattery = true, BatteryPercent = null, BatteryLifeMinutes = null };
+            host.TickForTest();
+
+            var data = (IReadOnlyDictionary<string, object>)Assert.Single(PowerEvents()).TypedPayload!;
+            Assert.Equal("unknown", data["batteryPercent"]);
+            Assert.Equal("unknown", data["batteryLifeMinutes"]);
+        }
+    }
+}
@@ -35,6 +35,8 @@ namespace AutopilotMonitor.Agent.V2.Core.Tests.Orchestration
        // OS-eventlog forwarding — observability, not enrollment progress (session 8bc1180f:
        // an EventID-100 burst must not keep the periodic collectors alive).
        [InlineData("modern_deployment_log")]
+        // Environment observation — battery drain on an idle device must not reset idle clocks.
+        [InlineData("power_state_change")]
        // Agent health / control / transport — not device/enrollment progress (P2).
        [InlineData("collector_degraded")]
        [InlineData("telemetry_upload_poisoned")]
@@ -245,11 +245,13 @@ namespace AutopilotMonitor.Agent.V2.Core.Tests.SignalAdapters
        }

        [Fact]
-        public void Terminal_to_active_retry_rearms_CompletedAt_and_final_terminal_covers_total_occupancy()
+        public void Terminal_to_active_retry_rearms_BothEndpoints_and_final_terminal_covers_last_attempt()
        {
-            // Audit Q1: the IME retry path (Error -> Downloading -> Installed is permitted by
-            // AppPackageState.UpdateState). Pre-fix, CompletedAt froze at the first Error, so
-            // the final Installed payload carried the first failure's completedAt/duration.
+            // Audit Q1 + 2026-08 attempt-duration change: the IME retry path
+            // (Error -> Downloading -> Installed is permitted by AppPackageState.UpdateState).
+            // A terminal->active transition re-arms BOTH endpoints, so the final Installed
+            // payload describes the retry ATTEMPT (matching the backend's AppInstallSummaries
+            // semantics) — not the first-start -> last-terminal span across attempts.
            using var f = new ImeLogTrackerAdapterFixture(T0);
            using var adapter = new ImeLogTrackerAdapter(f.Tracker, f.Ingress, f.Clock);
            var app = new AppPackageState("app-R", 0);
@@ -261,23 +263,23 @@ namespace AutopilotMonitor.Agent.V2.Core.Tests.SignalAdapters
            adapter.TriggerAppStateFromTest(app, AppInstallationState.Error, AppInstallationState.Downloading);

            // Re-armed while active again: the retry's download event carries no completedAt,
-            // and the FIRST start stamp is kept.
+            // and the start stamp is the RETRY's re-entry time (fresh attempt window).
            Assert.Null(adapter.AppTimings["app-R"].CompletedAtUtc);
            var retryDownload = f.InfoEvent(SharedEventTypes.AppDownloadStarted);
            Assert.False(retryDownload.Payload!.ContainsKey("completedAt"));
            Assert.False(retryDownload.Payload.ContainsKey("durationSeconds"));
-            Assert.Equal(T0.ToString("o"), retryDownload.Payload["startedAt"]);
+            Assert.Equal(T0.AddSeconds(15).ToString("o"), retryDownload.Payload["startedAt"]);

            f.Clock.Advance(TimeSpan.FromSeconds(20));
            adapter.TriggerAppStateFromTest(app, AppInstallationState.Downloading, AppInstallationState.Installed);

            var timing = adapter.AppTimings["app-R"];
-            Assert.Equal(T0, timing.StartedAtUtc);
+            Assert.Equal(T0.AddSeconds(15), timing.StartedAtUtc);
            Assert.Equal(T0.AddSeconds(35), timing.CompletedAtUtc);
-            Assert.Equal(35.0, timing.DurationSeconds);
+            Assert.Equal(20.0, timing.DurationSeconds);

            var completed = Assert.Single(f.InfoEvents(SharedEventTypes.AppInstallComplete));
-            Assert.Equal("35.00", completed.Payload!["durationSeconds"]);
+            Assert.Equal("20.00", completed.Payload!["durationSeconds"]);
            Assert.Equal(T0.AddSeconds(35).ToString("o"), completed.Payload["completedAt"]);
        }

@@ -10,10 +10,13 @@ namespace AutopilotMonitor.Agent.V2.Core.Monitoring.Enrollment.Ime
    /// the <c>app_tracking_summary</c> terminal event.
    /// <para>
    /// <b>StartedAtUtc</b> is recorded on the first lifecycle transition into Downloading /
-    /// Installing / InProgress and never overwritten. <b>CompletedAtUtc</b> is recorded on a
-    /// transition to a terminal state (Installed / Skipped / Postponed / Error) and re-armed
-    /// to <c>null</c> when the app goes terminal → active again (IME retry / re-evaluation,
-    /// audit Q1) — so the final terminal event carries first-start → last-terminal.
+    /// Installing / InProgress. <b>CompletedAtUtc</b> is recorded on a transition to a
+    /// terminal state (Installed / Skipped / Postponed / Error). When the app goes
+    /// terminal → active again (IME retry / re-evaluation pass, audit Q1) BOTH endpoints
+    /// re-arm — CompletedAtUtc to <c>null</c>, StartedAtUtc to the re-entry time — so the
+    /// final terminal event carries the status-defining ATTEMPT's window (2026-08
+    /// attempt-duration change, matching the backend's AppInstallSummaries semantics),
+    /// never the first-start → last-terminal span across install passes.
    /// </para>
    /// </summary>
    public sealed class AppInstallTiming
@@ -0,0 +1,197 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AutopilotMonitor.Agent.V2.Core.Runtime;
+using AutopilotMonitor.Shared.Models;
+
+namespace AutopilotMonitor.Agent.V2.Core.Monitoring.Enrollment.SystemSignals
+{
+    /// <summary>
+    /// Pure state machine behind <c>PowerStateWatcherHost</c>: diffs successive
+    /// <see cref="PowerStateResult"/> snapshots into <c>power_state_change</c> emissions.
+    /// No WMI, no timers, no logging — fully deterministic and unit-testable.
+    /// <para>
+    /// Semantics:
+    /// <list type="bullet">
+    ///   <item><b>AC↔battery transitions</b> — one emission per accepted edge
+    ///         (<c>ac_to_battery</c> Warning/immediate, <c>battery_to_ac</c> Info).</item>
+    ///   <item><b>Threshold ladder</b> (default 50/30/15 %) — evaluated only while ON battery;
+    ///         each level latches once per tracker lifetime (no re-emit when the device charges
+    ///         back up and drains again — avoids plug-cycle alarm spam). A multi-level jump
+    ///         emits only the LOWEST newly-crossed level. Entering battery power already below
+    ///         a level counts as crossing it (covers "unplugged at 12 %" and, via
+    ///         <see cref="Baseline"/>, "enrollment started at 12 %").</item>
+    ///   <item><b>Storm cap</b> — a lifetime emission cap (default 20) as backstop against a
+    ///         flapping dock / dying battery controller; <see cref="EmissionCapReached"/> flips
+    ///         once so the host can log a single warning.</item>
+    /// </list>
+    /// A snapshot with <see cref="PowerStateResult.ProbeError"/> is ignored (previous state
+    /// preserved); a null <see cref="PowerStateResult.BatteryPercent"/> skips threshold
+    /// evaluation but AC diffing still works.
+    /// </para>
+    /// </summary>
+    internal sealed class PowerStateTransitionTracker
+    {
+        public const string TransitionAcToBattery = "ac_to_battery";
+        public const string TransitionBatteryToAc = "battery_to_ac";
+        public const string TransitionThresholdCrossed = "threshold_crossed";
+
+        internal static readonly int[] DefaultThresholdLadder = { 50, 30, 15 };
+        internal const int DefaultMaxEmissions = 20;
+
+        private readonly int[] _ladder;              // strictly descending
+        private readonly int _maxEmissions;
+        private readonly HashSet<int> _latchedLevels = new HashSet<int>();
+
+        private bool _hasState;
+        private bool _lastOnAc;
+        private int _emitted;
+
+        public PowerStateTransitionTracker(IReadOnlyList<int>? thresholdLadder = null, int maxEmissions = DefaultMaxEmissions)
+        {
+            _ladder = (thresholdLadder ?? DefaultThresholdLadder).OrderByDescending(l => l).ToArray();
+            _maxEmissions = maxEmissions;
+        }
+
+        /// <summary>True once the lifetime emission cap suppressed at least one emission.</summary>
+        public bool EmissionCapReached { get; private set; }
+
+        /// <summary>
+        /// Latches the arm-time state silently — except when the device is already on battery
+        /// at/below a ladder level, which yields one threshold emission for the lowest crossed
+        /// level (an enrollment STARTING at 12 % must still produce the event the analyze rule
+        /// matches on). No AC-transition emission is ever produced from a baseline.
+        /// </summary>
+        public IReadOnlyList<PowerStateEmission> Baseline(PowerStateResult probe)
+        {
+            if (probe == null || probe.ProbeError != null || !probe.HasBattery)
+                return Array.Empty<PowerStateEmission>();
+
+            _hasState = true;
+            _lastOnAc = probe.OnAcPower;
+
+            var emissions = new List<PowerStateEmission>();
+            EvaluateThresholds(probe, emissions);
+            return emissions;
+        }
+
+        /// <summary>
+        /// Diffs a fresh (host-debounced) snapshot against the last accepted state and returns
+        /// 0..n emissions — an AC transition and a threshold crossing can co-occur (unplugged
+        /// at 10 % ⇒ <c>ac_to_battery</c> + <c>threshold_crossed:15</c>).
+        /// </summary>
+        public IReadOnlyList<PowerStateEmission> Evaluate(PowerStateResult probe)
+        {
+            if (probe == null || probe.ProbeError != null)
+                return Array.Empty<PowerStateEmission>();
+            if (!_hasState)
+                return Baseline(probe);
+
+            var emissions = new List<PowerStateEmission>();
+
+            if (_lastOnAc && !probe.OnAcPower)
+            {
+                Emit(emissions, new PowerStateEmission(
+                    transition: TransitionAcToBattery,
+                    thresholdPercent: null,
+                    probe: probe,
+                    severity: EventSeverity.Warning,
+                    immediateUpload: true,
+                    message: $"Power source switched from AC to battery ({FormatPercent(probe)} remaining) during enrollment"));
+            }
+            else if (!_lastOnAc && probe.OnAcPower)
+            {
+                Emit(emissions, new PowerStateEmission(
+                    transition: TransitionBatteryToAc,
+                    thresholdPercent: null,
+                    probe: probe,
+                    severity: EventSeverity.Info,
+                    immediateUpload: false,
+                    message: $"Power source switched back to AC ({FormatPercent(probe)}{(probe.IsCharging ? ", charging" : string.Empty)})"));
+            }
+
+            _lastOnAc = probe.OnAcPower;
+            EvaluateThresholds(probe, emissions);
+            return emissions;
+        }
+
+        /// <summary>
+        /// While on battery with a known percentage: emit the LOWEST ladder level at/above the
+        /// current charge that is not yet latched, then latch every level at/above the charge
+        /// (a 60 %→10 % jump emits threshold 15 only, latching 50/30/15).
+        /// </summary>
+        private void EvaluateThresholds(PowerStateResult probe, List<PowerStateEmission> emissions)
+        {
+            if (probe.OnAcPower || !probe.BatteryPercent.HasValue) return;
+            var percent = probe.BatteryPercent.Value;
+
+            int? lowestCrossed = null;
+            foreach (var level in _ladder) // descending — the last match is the lowest crossed level
+            {
+                if (percent <= level && !_latchedLevels.Contains(level))
+                    lowestCrossed = level;
+            }
+            if (!lowestCrossed.HasValue) return;
+
+            foreach (var level in _ladder)
+            {
+                if (percent <= level) _latchedLevels.Add(level);
+            }
+
+            var threshold = lowestCrossed.Value;
+            var severity = threshold <= 15 ? EventSeverity.Error
+                         : threshold <= 30 ? EventSeverity.Warning
+                         : EventSeverity.Info;
+            Emit(emissions, new PowerStateEmission(
+                transition: TransitionThresholdCrossed,
+                thresholdPercent: threshold,
+                probe: probe,
+                severity: severity,
+                immediateUpload: severity >= EventSeverity.Warning,
+                message: $"Battery dropped below {threshold}% ({FormatPercent(probe)} remaining) while enrolling on battery power"));
+        }
+
+        private void Emit(List<PowerStateEmission> emissions, PowerStateEmission emission)
+        {
+            if (_emitted >= _maxEmissions)
+            {
+                EmissionCapReached = true;
+                return;
+            }
+            _emitted++;
+            emissions.Add(emission);
+        }
+
+        private static string FormatPercent(PowerStateResult probe)
+            => probe.BatteryPercent.HasValue ? $"battery {probe.BatteryPercent.Value}%" : "battery level unknown";
+    }
+
+    /// <summary>One decided <c>power_state_change</c> emission — the host maps this 1:1 onto an event.</summary>
+    internal sealed class PowerStateEmission
+    {
+        public PowerStateEmission(string transition, int? thresholdPercent, PowerStateResult probe,
+            EventSeverity severity, bool immediateUpload, string message)
+        {
+            Transition = transition;
+            ThresholdPercent = thresholdPercent;
+            OnAcPower = probe.OnAcPower;
+            BatteryPercent = probe.BatteryPercent;
+            IsCharging = probe.IsCharging;
+            BatteryLifeMinutes = probe.BatteryLifeMinutes;
+            Severity = severity;
+            ImmediateUpload = immediateUpload;
+            Message = message;
+        }
+
+        public string Transition { get; }
+        public int? ThresholdPercent { get; }
+        public bool OnAcPower { get; }
+        public int? BatteryPercent { get; }
+        public bool IsCharging { get; }
+        public int? BatteryLifeMinutes { get; }
+        public EventSeverity Severity { get; }
+        public bool ImmediateUpload { get; }
+        public string Message { get; }
+    }
+}
@@ -595,6 +595,21 @@ namespace AutopilotMonitor.Agent.V2.Core.Orchestration
                logger: logger,
                apiBaseUrl: _agentConfig.ApiBaseUrl));

+            // Live AC/battery watcher — WMI Win32_PowerManagementEvent push (no polling), emits
+            // power_state_change on AC↔battery transitions and 50/30/15 % downward threshold
+            // crossings. Deliberately NOT under PeriodicCollectorLifecycleHost: it is push-based
+            // (zero idle cost) and must stay alive precisely when the device sits idle on battery.
+            // Never arms on devices without a battery. Kill-switchable via remote config.
+            if (collectors.EnablePowerStateWatcher)
+            {
+                hosts.Add(new PowerStateWatcherHost(
+                    sessionId: sessionId,
+                    tenantId: tenantId,
+                    ingress: ingress,
+                    clock: clock,
+                    logger: logger));
+            }
+
            // Microsoft 365 Apps (Office C2R) install detector — event-driven (Rev 2): woken by a WMI
            // Win32_ProcessStartTrace push on OfficeC2RClient.exe (+ startup probe), progress via
            // RegNotifyChangeKeyValue, stop via Process.Exited. No idle polling. Constructed first so
@@ -0,0 +1,332 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Management;
+using System.Threading;
+using AutopilotMonitor.Agent.V2.Core.Logging;
+using AutopilotMonitor.Agent.V2.Core.Monitoring.Enrollment.SystemSignals;
+using AutopilotMonitor.Agent.V2.Core.Runtime;
+using AutopilotMonitor.DecisionCore.Engine;
+using AutopilotMonitor.Shared;
+using AutopilotMonitor.Shared.Models;
+
+namespace AutopilotMonitor.Agent.V2.Core.Orchestration
+{
+    /// <summary>
+    /// Live AC/battery watcher: subscribes to the WMI push event
+    /// <c>Win32_PowerManagementEvent WHERE EventCode = 10</c> (PBT_APMPOWERSTATUSCHANGE — fires on
+    /// AC↔DC switches and battery-percentage steps), falling back to the intrinsic
+    /// <c>__InstanceModificationEvent WITHIN 30 … Win32_Battery</c> where the legacy push provider
+    /// no longer loads (Windows 11 24H2/25H2, builds 26200+: activation fails WBEM_E_NOT_FOUND
+    /// although the provider is still registered — session 161b838c). Either way the arriving
+    /// event's payload is ignored; each arrival re-probes via <see cref="PowerStateProbe"/> and
+    /// diffs the snapshots through the pure <see cref="PowerStateTransitionTracker"/> into
+    /// <c>power_state_change</c> events. No polling in this process (the fallback's WITHIN
+    /// sampling runs inside WinMgmt). Complements the one-shot startup
+    /// <c>power_state_check</c> (<c>StartupEnvironmentProbes</c>), which stays the baseline event.
+    /// <para>
+    /// Devices without a battery (or with a failing probe) never arm the WMI subscription — zero
+    /// overhead on desktops/VMs. WMI arming runs on a background thread (WinMgmt can hang in OOBE;
+    /// same rationale as <c>ConsoleBypassWatcher</c>), and an arm failure is surfaced once as
+    /// <c>collector_degraded</c>. A 5 s trailing-edge debounce collapses docking flaps to a
+    /// no-diff; the tracker's lifetime emission cap is the storm backstop.
+    /// </para>
+    /// </summary>
+    internal sealed class PowerStateWatcherHost : ICollectorHost
+    {
+        public string Name => "PowerStateWatcher";
+
+        private static readonly TimeSpan DebounceDelay = TimeSpan.FromSeconds(5);
+
+        private readonly string _sessionId;
+        private readonly string _tenantId;
+        private readonly AgentLogger _logger;
+        private readonly InformationalEventPost _post;
+        private readonly Func<PowerStateResult> _probe;
+        private readonly PowerStateTransitionTracker _tracker = new PowerStateTransitionTracker();
+        private readonly object _lock = new object();
+        private readonly object _tickLock = new object();
+
+        private ManagementEventWatcher? _watcher;
+        private Timer? _debounceTimer;
+        private bool _started;
+        private bool _disposed;
+        private bool _capWarned;
+
+        /// <param name="probe">Power-state snapshot source; test seam, defaults to
+        /// <see cref="PowerStateProbe.Probe"/>. The ctor never calls it (the factory constructs
+        /// hosts eagerly; all probing happens in <see cref="Start"/>'s background thread).</param>
+        public PowerStateWatcherHost(
+            string sessionId,
+            string tenantId,
+            ISignalIngressSink ingress,
+            IClock clock,
+            AgentLogger logger,
+            Func<PowerStateResult>? probe = null)
+        {
+            if (ingress == null) throw new ArgumentNullException(nameof(ingress));
+            if (clock == null) throw new ArgumentNullException(nameof(clock));
+            _sessionId = sessionId;
+            _tenantId = tenantId;
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _post = new InformationalEventPost(ingress, clock, logger);
+            _probe = probe ?? PowerStateProbe.Probe;
+        }
+
+        public void Start()
+        {
+            lock (_lock)
+            {
+                if (_started || _disposed) return;
+                _started = true;
+            }
+
+            // Baseline probe + WMI arming are synchronous WinMgmt-adjacent operations and WinMgmt
+            // can hang during OOBE — never run them inline on the orchestrator's sequential
+            // host-start loop (ConsoleBypassWatcher precedent). Disposal racing the background
+            // start is handled by the _disposed re-checks inside StartCore.
+            System.Threading.Tasks.Task.Run(() => StartCore(armWmi: true));
+        }
+
+        /// <summary>Internal for tests: the synchronous start body; tests pass
+        /// <paramref name="armWmi"/> = false so no real WMI subscription is created
+        /// (precedent: ConsoleBypassWatcher leaves WMI arming untested).</summary>
+        internal void StartCore(bool armWmi)
+        {
+            PowerStateResult baseline;
+            try
+            {
+                baseline = _probe();
+            }
+            catch (Exception ex)
+            {
+                _logger.Warning($"[{Name}] baseline probe threw ({ex.Message}) — power-state watcher not armed");
+                return;
+            }
+
+            if (baseline.ProbeError != null)
+            {
+                _logger.Info($"[{Name}] power probe failed ({baseline.ProbeError}) — watcher not armed");
+                return;
+            }
+            if (!baseline.HasBattery)
+            {
+                _logger.Info($"[{Name}] no battery present (desktop/VM) — watcher not armed");
+                return;
+            }
+
+            // Latch the baseline BEFORE arming so the first WMI push diffs against a real state.
+            // A session already on battery below a ladder level emits its threshold event here.
+            EmitAll(_tracker.Baseline(baseline));
+
+            if (!armWmi) return;
+
+            // Arm chain: the extrinsic push event first (zero WinMgmt cost, still alive on older
+            // builds), then the intrinsic Win32_Battery modification event. On Windows 11 24H2/25H2
+            // (observed on builds 26200/26220, session 161b838c) the MS_Power_Management_Event_Provider
+            // is still REGISTERED but its activation fails with WBEM_E_NOT_FOUND — the legacy provider
+            // no longer loads, so the push query throws on exactly the devices that enroll today.
+            // The fallback's WITHIN polling runs inside WinMgmt (a Win32_Battery snapshot every 30 s),
+            // NOT in this process; the handler path is identical (payload ignored, re-probe + diff),
+            // worst-case detection latency ≈ 35 s incl. debounce.
+            if (TryArmWatcher(
+                    "SELECT * FROM Win32_PowerManagementEvent WHERE EventCode = 10",
+                    "power_management_event (push)", baseline, out var pushError))
+            {
+                return;
+            }
+
+            if (TryArmWatcher(
+                    "SELECT * FROM __InstanceModificationEvent WITHIN 30 WHERE TargetInstance ISA 'Win32_Battery'",
+                    "battery_instance_poll (WinMgmt WITHIN 30s)", baseline, out var fallbackError))
+            {
+                return;
+            }
+
+            _logger.Warning($"[{Name}] could not arm any WMI power watcher — " +
+                $"push: {Describe(pushError)}; fallback: {Describe(fallbackError)} — " +
+                "live power-state transitions will not be observed this run");
+            CollectorDegradationReporter.Report(_post, _sessionId, _tenantId, Name, "watcher_arm_failed",
+                fallbackError ?? pushError);
+        }
+
+        private static string Describe(Exception? ex)
+            => ex == null ? "n/a" : $"{ex.GetType().Name}: {ex.Message}";
+
+        /// <summary>
+        /// One arm attempt for the given WQL event query, with the full dispose-race dance
+        /// (ConsoleBypassWatcher pattern). Returns true when the chain should stop: the watcher
+        /// armed, or disposal won the race (then arming anything would leak a subscription).
+        /// Returns false with the captured exception so the caller can try the next query.
+        /// </summary>
+        private bool TryArmWatcher(string wql, string modeLabel, PowerStateResult baseline, out Exception? error)
+        {
+            error = null;
+            try
+            {
+                var watcher = new ManagementEventWatcher(new WqlEventQuery(wql));
+                watcher.EventArrived += OnPowerStatusChange;
+
+                lock (_lock)
+                {
+                    if (_disposed)
+                    {
+                        // Dispose won the race against the background start — don't arm.
+                        try { watcher.EventArrived -= OnPowerStatusChange; } catch { }
+                        try { watcher.Dispose(); } catch { }
+                        return true;
+                    }
+                    _watcher = watcher;
+                }
+
+                watcher.Start();
+
+                // Re-check after arming: Dispose() may have run between the lock release above and
+                // Start() — it then stopped a not-yet-armed watcher and this thread armed it right
+                // back. If disposal won that race, tear the watcher down here.
+                bool disposedDuringArm;
+                lock (_lock)
+                {
+                    disposedDuringArm = _disposed;
+                    if (disposedDuringArm) _watcher = null;
+                }
+                if (disposedDuringArm)
+                {
+                    try { watcher.EventArrived -= OnPowerStatusChange; } catch { }
+                    try { watcher.Stop(); } catch { }
+                    try { watcher.Dispose(); } catch { }
+                    return true;
+                }
+
+                _logger.Info($"[{Name}] armed via {modeLabel} — " +
+                    $"baseline: {(baseline.OnAcPower ? "AC" : "battery")}, {baseline.BatteryPercent?.ToString() ?? "?"}%");
+                return true;
+            }
+            catch (Exception ex)
+            {
+                error = ex;
+                _logger.Info($"[{Name}] arm attempt '{modeLabel}' failed ({ex.GetType().Name}: {ex.Message})");
+                lock (_lock) { _watcher = null; }
+                return false;
+            }
+        }
+
+        private void OnPowerStatusChange(object sender, EventArrivedEventArgs e)
+        {
+            // Push and fallback events are treated identically: the payload is ignored, the event
+            // only tells us "power status may have changed". Debounce, then re-probe — never call
+            // watcher.Stop() from inside this callback.
+            try { ScheduleDebouncedTick(); }
+            catch (Exception ex) { _logger.Debug($"[{Name}] power event handler error: {ex.Message}"); }
+        }
+
+        private void ScheduleDebouncedTick()
+        {
+            lock (_lock) { if (_disposed) return; }
+            // One trailing-edge tick per change burst (ImeRegistryAppStateHost pattern): a
+            // dock-flap AC→battery→AC inside the window collapses to a no-diff in the tracker.
+            var timer = _debounceTimer;
+            if (timer == null)
+            {
+                var created = new Timer(_ => DebouncedTick(), null, DebounceDelay, Timeout.InfiniteTimeSpan);
+                if (Interlocked.CompareExchange(ref _debounceTimer, created, null) != null)
+                    created.Dispose();
+                else
+                    return;
+                timer = _debounceTimer;
+            }
+            try { timer?.Change(DebounceDelay, Timeout.InfiniteTimeSpan); }
+            catch (ObjectDisposedException) { /* stopping */ }
+        }
+
+        /// <summary>Internal for tests: runs one debounced probe/diff/emit cycle synchronously,
+        /// exactly what the trailing-edge timer callback executes after a WMI push.</summary>
+        internal void TickForTest() => DebouncedTick();
+
+        private void DebouncedTick()
+        {
+            lock (_lock) { if (_disposed) return; }
+            try
+            {
+                IReadOnlyList<PowerStateEmission> emissions;
+                lock (_tickLock) // tracker is not thread-safe; ticks must not interleave
+                {
+                    emissions = _tracker.Evaluate(_probe());
+                }
+                EmitAll(emissions);
+
+                if (_tracker.EmissionCapReached && !_capWarned)
+                {
+                    _capWarned = true;
+                    _logger.Warning($"[{Name}] emission cap reached — further power_state_change events " +
+                        "suppressed this run (flapping power source or dying battery controller)");
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.Debug($"[{Name}] debounced power tick failed: {ex.Message}");
+            }
+        }
+
+        private void EmitAll(IReadOnlyList<PowerStateEmission> emissions)
+        {
+            foreach (var emission in emissions)
+            {
+                try
+                {
+                    var data = new Dictionary<string, object>
+                    {
+                        { "transition", emission.Transition },
+                        { "onAcPower", emission.OnAcPower },
+                        { "batteryPercent", emission.BatteryPercent.HasValue ? (object)emission.BatteryPercent.Value : "unknown" },
+                        { "isCharging", emission.IsCharging },
+                        { "batteryLifeMinutes", emission.BatteryLifeMinutes.HasValue ? (object)emission.BatteryLifeMinutes.Value : "unknown" },
+                    };
+                    if (emission.ThresholdPercent.HasValue)
+                        data["thresholdPercent"] = emission.ThresholdPercent.Value;
+
+                    _post.Emit(new EnrollmentEvent
+                    {
+                        SessionId = _sessionId,
+                        TenantId = _tenantId,
+                        EventType = Constants.EventTypes.PowerStateChange,
+                        Severity = emission.Severity,
+                        Source = Name,
+                        Phase = EnrollmentPhase.Unknown,
+                        Message = emission.Message,
+                        ImmediateUpload = emission.ImmediateUpload,
+                        Data = data,
+                    });
+                }
+                catch (Exception ex)
+                {
+                    _logger.Warning($"[{Name}] failed to emit power_state_change: {ex.Message}");
+                }
+            }
+        }
+
+        public void Stop()
+        {
+            ManagementEventWatcher? watcher;
+            lock (_lock)
+            {
+                if (_disposed) return;
+                _disposed = true;
+                watcher = _watcher;
+                _watcher = null;
+            }
+
+            if (watcher != null)
+            {
+                try { watcher.EventArrived -= OnPowerStatusChange; } catch { }
+                try { watcher.Stop(); } catch { }
+                try { watcher.Dispose(); } catch { }
+            }
+
+            _debounceTimer?.Dispose();
+            _debounceTimer = null;
+        }
+
+        public void Dispose() => Stop();
+    }
+}
@@ -56,6 +56,11 @@ namespace AutopilotMonitor.Agent.V2.Core.Orchestration
            // real activity (rare, and worth keeping diagnostics running for).
            SharedConstants.EventTypes.ModernDeploymentLog,

+            // Environment observation, not device/enrollment progress: an idle device draining
+            // its battery must not keep the periodic collectors alive or push out stall
+            // detection — the exact scenario the power watcher exists to observe.
+            SharedConstants.EventTypes.PowerStateChange,
+
            // Agent health / control / transport — not device/enrollment progress.
            SharedConstants.EventTypes.CollectorDegraded,
            SharedConstants.EventTypes.TelemetryUploadPoisoned,
@@ -804,12 +804,15 @@ namespace AutopilotMonitor.Agent.V2.Core.SignalAdapters
        /// <see cref="AppInstallTiming"/> so the emitter can inline the values on the
        /// current event's payload without a second dictionary lookup.
        /// <para>
-        /// Audit Q1: a terminal→active transition (the IME retry path — <see
-        /// cref="AppPackageState.UpdateState"/> permits e.g. Error→Downloading and
-        /// Skipped→Downloading) re-arms <c>Completed</c> to <c>null</c>, so the NEXT terminal
-        /// transition stamps a fresh CompletedAt. StartedAt keeps its first value — the final
-        /// terminal payload then covers first-start → last-terminal (total occupancy across
-        /// attempts) instead of freezing at the first failure. Observed pre-fix: a user-scope
+        /// Audit Q1 + 2026-08 attempt-duration change: a terminal→active transition (the IME
+        /// retry / re-evaluation path — <see cref="AppPackageState.UpdateState"/> permits e.g.
+        /// Error→Downloading and Skipped→Downloading) re-arms BOTH endpoints: <c>Completed</c>
+        /// to <c>null</c> (the NEXT terminal transition stamps fresh) and <c>Started</c> to
+        /// the re-entry time. The final terminal payload therefore describes the
+        /// status-defining ATTEMPT — matching the backend's AppInstallSummaries semantics —
+        /// instead of first-start → last-terminal across passes: the IME processes the app
+        /// list repeatedly (device-ESP evaluation pass, user-context pass), and the idle gap
+        /// between passes is not install time. Observed pre-fix (old bug shape): a user-scope
        /// app Skipped early in DeviceSetup, retried after sign-in, emitted its final
        /// Installed event with the stale early CompletedAt (durationSeconds=-2342).
        /// </para>
@@ -820,11 +823,13 @@ namespace AutopilotMonitor.Agent.V2.Core.SignalAdapters
            {
                _appTimings.TryGetValue(appId, out var current);

-                // Terminal→active (retry): the earlier terminal stamp no longer describes this
-                // app's outcome — re-arm so the next terminal transition stamps fresh.
+                // Terminal→active (retry / new pass): the earlier stamps no longer describe
+                // this app's outcome — re-arm both endpoints so the next terminal transition
+                // reports the fresh attempt's window.
                if (current.Completed != null && IsLifecycleActive(newState))
                {
                    current.Completed = null;
+                    current.Started = now;
                }

                // First lifecycle-active transition → record StartedAt.
@@ -198,4 +198,164 @@ public class AppInstallTerminalStateAndReconcileTests
        // Column absent → Merge-mode preserves a prior batch's terminal state.
        Assert.False(empty.ContainsKey("TerminalState"));
    }
+
+    // ── attempt-duration semantics (2026-08): the field case that motivated it ──
+    // Session 44862cd3, "Set TimeZone": device-ESP evaluation pass ends Skipped, the real
+    // install happens ~66 min later in the user-context pass and takes 23 s. The old span
+    // semantics reported 4002 s.
+
+    [Fact]
+    public void TwoPasses_SingleBatch_DurationIsLastAttempt_NotSpan()
+    {
+        var s = Aggregate(
+            AppEvent("app_install_started", T0),
+            AppEvent("app_install_completed", T0.AddMinutes(6), "Skipped"),
+            AppEvent("app_install_started", T0.AddMinutes(66)),
+            AppEvent("app_install_completed", T0.AddMinutes(66).AddSeconds(23), "Installed"))["App"].Summary;
+
+        Assert.Equal(23, s.DurationSeconds);                        // last attempt, not 3983 s
+        Assert.Equal(T0, s.StartedAt);                              // first-seen anchor untouched
+        Assert.Equal(T0.AddMinutes(66), s.LastAttemptStartedAt);
+        Assert.Equal(2, s.InstallPassCount);
+        Assert.Equal("Installed", s.TerminalState);
+        Assert.Equal(T0.AddMinutes(66).AddSeconds(23), s.CompletedAt);
+    }
+
+    [Fact]
+    public void WeakerTerminal_CompletedSkipped_NeverOverridesInstalled_InBatch()
+    {
+        // Re-evaluation after a real install reports Skipped (already present) — the row
+        // keeps describing the install attempt, incl. CompletedAt and duration.
+        var s = Aggregate(
+            AppEvent("app_install_started", T0),
+            AppEvent("app_install_completed", T0.AddSeconds(40), "Installed"),
+            AppEvent("app_install_started", T0.AddMinutes(30)),
+            AppEvent("app_install_completed", T0.AddMinutes(30).AddSeconds(2), "Skipped"))["App"].Summary;
+
+        Assert.Equal("Installed", s.TerminalState);
+        Assert.Equal(T0.AddSeconds(40), s.CompletedAt);
+        Assert.Equal(40, s.DurationSeconds);
+    }
+
+    [Fact]
+    public void StartInOneBatch_TerminalInNext_ReconcileAnchorsOnStoredAttempt()
+    {
+        // Pass 2 start landed in batch N (stored anchor); the terminal-only batch N+1 must
+        // pair against it — not against the first-seen StartedAt an hour earlier.
+        var existing = new TableEntity("tenant", "session_App")
+        {
+            ["Status"] = "InProgress",
+            ["StartedAt"] = new DateTimeOffset(T0),
+            ["LastAttemptStartedAt"] = new DateTimeOffset(T0.AddMinutes(66)),
+            ["InstallPassCount"] = 2,
+        };
+        var summary = new AppInstallSummary
+        {
+            AppName = "App", SessionId = "session", TenantId = "tenant",
+            Status = "Succeeded", TerminalState = "Installed",
+            StartedAt = T0.AddMinutes(66).AddSeconds(23),           // batch init stamp (terminal event)
+            CompletedAt = T0.AddMinutes(66).AddSeconds(23),
+        };
+
+        TableStorageService.ReconcileAppInstallSummaryWithExisting(summary, existing);
+
+        Assert.Equal(T0, summary.StartedAt);                        // earliest wins (window key)
+        Assert.Equal(T0.AddMinutes(66), summary.LastAttemptStartedAt);
+        Assert.Equal(23, summary.DurationSeconds);                  // attempt-anchored, not 3983 s
+        Assert.Equal(2, summary.InstallPassCount);
+    }
+
+    [Fact]
+    public void Reconcile_ReplayedOlderBatch_NeverRegressesAnchorOrDoubleCountsPasses()
+    {
+        var existing = new TableEntity("tenant", "session_App")
+        {
+            ["StartedAt"] = new DateTimeOffset(T0),
+            ["LastAttemptStartedAt"] = new DateTimeOffset(T0.AddMinutes(66)),
+            ["InstallPassCount"] = 2,
+        };
+        // Replay of the pass-1 batch: its newest start is OLDER than the stored anchor.
+        var summary = new AppInstallSummary
+        {
+            AppName = "App", Status = "InProgress",
+            StartedAt = T0, LastAttemptStartedAt = T0, InstallPassCount = 1,
+        };
+
+        TableStorageService.ReconcileAppInstallSummaryWithExisting(summary, existing);
+
+        Assert.Equal(T0.AddMinutes(66), summary.LastAttemptStartedAt);  // max-fold: no regression
+        Assert.Equal(2, summary.InstallPassCount);                      // not 3 — replay not re-counted
+    }
+
+    [Fact]
+    public void Reconcile_NewerAttemptBatch_AddsPassCount()
+    {
+        var existing = new TableEntity("tenant", "session_App")
+        {
+            ["StartedAt"] = new DateTimeOffset(T0),
+            ["LastAttemptStartedAt"] = new DateTimeOffset(T0),
+            ["InstallPassCount"] = 1,
+        };
+        var summary = new AppInstallSummary
+        {
+            AppName = "App", Status = "InProgress",
+            StartedAt = T0.AddMinutes(66), LastAttemptStartedAt = T0.AddMinutes(66), InstallPassCount = 1,
+        };
+
+        TableStorageService.ReconcileAppInstallSummaryWithExisting(summary, existing);
+
+        Assert.Equal(T0.AddMinutes(66), summary.LastAttemptStartedAt);
+        Assert.Equal(2, summary.InstallPassCount);
+    }
+
+    [Fact]
+    public void Reconcile_WeakerTerminalBatch_NeverOverridesStoredInstalled()
+    {
+        // Cross-batch mirror of the in-batch guard: a batch that only saw the Skipped
+        // re-evaluation must not re-describe an Installed row.
+        var existing = new TableEntity("tenant", "session_App")
+        {
+            ["Status"] = "Succeeded",
+            ["TerminalState"] = "Installed",
+            ["StartedAt"] = new DateTimeOffset(T0),
+            ["CompletedAt"] = new DateTimeOffset(T0.AddSeconds(40)),
+            ["DurationSeconds"] = 40,
+        };
+        var summary = new AppInstallSummary
+        {
+            AppName = "App", Status = "Succeeded", TerminalState = "Skipped",
+            StartedAt = T0.AddMinutes(30),
+            LastAttemptStartedAt = T0.AddMinutes(30), InstallPassCount = 1,
+            CompletedAt = T0.AddMinutes(30).AddSeconds(2), DurationSeconds = 2,
+        };
+
+        TableStorageService.ReconcileAppInstallSummaryWithExisting(summary, existing);
+
+        Assert.Equal("Installed", summary.TerminalState);
+        // The guard drops the skip-pass endpoints; the Q4 path then re-adopts the STORED
+        // CompletedAt (the surviving install attempt's) — same value as on disk, and the
+        // attempt anchor being newer keeps DurationSeconds at 0, so the omitted column
+        // lets Merge preserve the stored 40 s.
+        Assert.Equal(T0.AddSeconds(40), summary.CompletedAt);
+        Assert.Equal(0, summary.DurationSeconds);
+    }
+
+    [Fact]
+    public void EntityBuilder_AttemptColumns_AreSentinelGated()
+    {
+        var with = new AppInstallSummary
+        {
+            AppName = "App",
+            LastAttemptStartedAt = T0,
+            InstallPassCount = 2,
+        };
+        var entity = TableStorageService.BuildAppInstallSummaryEntity(with, "rk");
+        Assert.Equal(new DateTimeOffset(T0), entity.GetDateTimeOffset("LastAttemptStartedAt"));
+        Assert.Equal(2, entity.GetInt32("InstallPassCount"));
+
+        var without = new AppInstallSummary { AppName = "App" };
+        var empty = TableStorageService.BuildAppInstallSummaryEntity(without, "rk");
+        Assert.False(empty.ContainsKey("LastAttemptStartedAt"));
+        Assert.False(empty.ContainsKey("InstallPassCount"));
+    }
 }
@@ -36,7 +36,8 @@ public class AppVersionRegressionRadarTests
        string appName = App,
        string status = "Succeeded",
        string terminalState = "Installed",
-        bool collision = false)
+        bool collision = false,
+        bool attemptAnchored = true)
        => new()
        {
            TenantId = TenantA,
@@ -47,6 +48,9 @@ public class AppVersionRegressionRadarTests
            TerminalState = terminalState,
            DurationSeconds = durationSeconds,
            StartedAt = startedAt ?? Now.AddDays(-1),
+            // Post-cutover rows carry the attempt anchor; the radar's cutover gate
+            // excludes rows without it (attemptAnchored: false = legacy span row).
+            LastAttemptStartedAt = attemptAnchored ? (startedAt ?? Now.AddDays(-1)) : null,
            AppIdCollision = collision,
        };

@@ -164,6 +168,26 @@ public class AppVersionRegressionRadarTests
        Assert.Equal(900, finding.CurrentMedianSeconds);
    }

+    [Fact]
+    public void Evaluate_CutoverGate_LegacySpanRows_ExcludedOnBothSides()
+    {
+        // 2026-08 attempt-duration cutover: rows without LastAttemptStartedAt carry the old
+        // full-span semantics and are excluded from BOTH comparison sides.
+
+        // Current side: 10 legacy span rows would fire (lift 3.0), but only 5 are
+        // attempt-anchored → below MinMeasuredInstalls → silent.
+        var rows = Batch("1.0", 10, 300, Now.AddDays(-20));
+        rows.AddRange(Enumerable.Range(0, 10).Select(_ => Install("2.0", 900, Now.AddDays(-5), attemptAnchored: false)));
+        rows.AddRange(Enumerable.Range(0, 5).Select(_ => Install("2.0", 900, Now.AddDays(-5))));
+        Assert.Empty(AppVersionRegressionRadar.Evaluate(rows));
+
+        // Previous side entirely legacy → gated away → no comparison basis → silent,
+        // even though the raw medians (300 → 900) would scream regression.
+        var rows2 = Enumerable.Range(0, 10).Select(_ => Install("1.0", 300, Now.AddDays(-20), attemptAnchored: false)).ToList();
+        rows2.AddRange(Batch("2.0", 10, 900, Now.AddDays(-5)));
+        Assert.Empty(AppVersionRegressionRadar.Evaluate(rows2));
+    }
+
    [Fact]
    public void Evaluate_DeterministicOrdering_LiftDesc_ThenAppNameOrdinal()
    {
@@ -0,0 +1,56 @@
+using AutopilotMonitor.Functions.Services;
+using AutopilotMonitor.Shared.Models;
+
+namespace AutopilotMonitor.Functions.Tests;
+
+/// <summary>
+/// Pins the shipped rule catalogs to the reserved built-in ID namespace from
+/// RuleIdPolicy: every built-in occupies (ANALYZE|GATHER)-&lt;CATEGORY&gt;-&lt;NUMBER&gt; with
+/// CATEGORY != CUSTOM, and IDs are unique (case-insensitively — case variants are
+/// indistinguishable to humans and to the policy regex). This is the backend-side
+/// enforcement of the "platform never ships a built-in in the CUSTOM namespace"
+/// commitment documented in RuleIdPolicy — without it, a shipped CUSTOM-ID rule
+/// would silently shadow every tenant's same-ID custom rule at merge time
+/// (global wins, tenant copy dropped). combine.js mirrors these checks at
+/// catalog-build time; this test guards the embedded resource actually deployed.
+/// </summary>
+public class BuiltInRuleCatalogPolicyTests
+{
+    [Fact]
+    public void BuiltIn_analyze_ids_are_reserved_namespace_and_unique()
+    {
+        var ids = BuiltInAnalyzeRules.GetAll().Select(r => r.RuleId).ToList();
+
+        Assert.NotEmpty(ids);
+        foreach (var id in ids)
+        {
+            Assert.True(RuleIdPolicy.IsReservedBuiltInId(id),
+                $"Built-in analyze rule '{id}' lies outside the reserved built-in namespace — " +
+                "it would collide with the tenant custom namespace.");
+        }
+
+        var duplicates = ids.GroupBy(id => id, StringComparer.OrdinalIgnoreCase)
+            .Where(g => g.Count() > 1).Select(g => g.Key).ToList();
+        Assert.True(duplicates.Count == 0,
+            $"Duplicate built-in analyze rule IDs: {string.Join(", ", duplicates)}");
+    }
+
+    [Fact]
+    public void BuiltIn_gather_ids_are_reserved_namespace_and_unique()
+    {
+        var ids = BuiltInGatherRules.GetAll().Select(r => r.RuleId).ToList();
+
+        Assert.NotEmpty(ids);
+        foreach (var id in ids)
+        {
+            Assert.True(RuleIdPolicy.IsReservedBuiltInId(id),
+                $"Built-in gather rule '{id}' lies outside the reserved built-in namespace — " +
+                "it would collide with the tenant custom namespace.");
+        }
+
+        var duplicates = ids.GroupBy(id => id, StringComparer.OrdinalIgnoreCase)
+            .Where(g => g.Count() > 1).Select(g => g.Key).ToList();
+        Assert.True(duplicates.Count == 0,
+            $"Duplicate built-in gather rule IDs: {string.Join(", ", duplicates)}");
+    }
+}
@@ -379,20 +379,50 @@ public class EventTimestampValidationTests
    }

    [Fact]
-    public void RecalculateAppDurations_DownloadThenInstall_CorrectDownloadDuration()
+    public void DownloadThenInstall_AttemptScopedPairing_DownloadAndInstallDurations()
    {
+        // 2026-08 attempt-duration change: DownloadDurationSeconds pairs the latest download
+        // start with the NEXT install start at event-fold time (no first→first span math),
+        // and DurationSeconds anchors on the install attempt (download time is reported
+        // separately, not folded into the install duration).
        var downloadStart = new DateTime(2026, 3, 30, 10, 0, 0, DateTimeKind.Utc);
        var installStart = downloadStart.AddSeconds(30);
        var completed = installStart.AddSeconds(45);

+        var summaries = new Dictionary<string, AppInstallAggregationState>(StringComparer.OrdinalIgnoreCase);
+        foreach (var evt in new[]
+        {
+            AppInstallEvent("app_download_started", downloadStart),
+            AppInstallEvent("app_install_started", installStart),
+            AppInstallEvent("app_install_completed", completed, "Installed"),
+        })
+        {
+            EventIngestProcessor.AggregateAppInstallEvent(evt, "tenant", "session", summaries);
+        }
+
+        var summary = summaries["TestApp"].Summary;
+        Assert.Equal(30, summary.DownloadDurationSeconds); // download→install gap
+        Assert.Equal(45, summary.DurationSeconds);         // install attempt only
+        Assert.Equal(installStart, summary.LastAttemptStartedAt);
+        Assert.Equal(downloadStart, summary.StartedAt);    // first-seen anchor
+    }
+
+    [Fact]
+    public void RecalculateAppDurations_AttemptAnchor_BeatsFirstSeenSpan()
+    {
+        // With an observed attempt start, the duration is the attempt — never the span
+        // back to the first observation an hour earlier.
+        var firstSeen = new DateTime(2026, 3, 30, 10, 0, 0, DateTimeKind.Utc);
+        var attemptStart = firstSeen.AddMinutes(60);
+        var completed = attemptStart.AddSeconds(45);
+
        var state = new AppInstallAggregationState
        {
-            DownloadStartedAt = downloadStart,
-            InstallStartedAt = installStart,
            Summary = new AppInstallSummary
            {
                AppName = "TestApp",
-                StartedAt = downloadStart,
+                StartedAt = firstSeen,
+                LastAttemptStartedAt = attemptStart,
                CompletedAt = completed,
                Status = "Succeeded"
            }
@@ -400,8 +430,46 @@ public class EventTimestampValidationTests

        EventIngestProcessor.RecalculateAppDurations(state);

-        Assert.Equal(30, state.Summary.DownloadDurationSeconds); // download→install gap
-        Assert.Equal(75, state.Summary.DurationSeconds);         // full duration
+        Assert.Equal(45, state.Summary.DurationSeconds);
+    }
+
+    [Fact]
+    public void RecalculateAppDurations_AttemptNewerThanCompletion_KeepsRecordedDuration()
+    {
+        // A fresh pass is in flight (start after the last terminal): CompletedAt belongs to
+        // the previous attempt — its recorded duration must stand.
+        var attempt1 = new DateTime(2026, 3, 30, 10, 0, 0, DateTimeKind.Utc);
+        var completed = attempt1.AddSeconds(40);
+        var attempt2 = completed.AddMinutes(30);
+
+        var state = new AppInstallAggregationState
+        {
+            Summary = new AppInstallSummary
+            {
+                AppName = "TestApp",
+                StartedAt = attempt1,
+                LastAttemptStartedAt = attempt2,
+                CompletedAt = completed,
+                DurationSeconds = 40,
+                Status = "Succeeded"
+            }
+        };
+
+        EventIngestProcessor.RecalculateAppDurations(state);
+
+        Assert.Equal(40, state.Summary.DurationSeconds);
+    }
+
+    private static EnrollmentEvent AppInstallEvent(string eventType, DateTime ts, string? state = null)
+    {
+        var evt = new EnrollmentEvent
+        {
+            EventType = eventType,
+            Timestamp = ts,
+            Data = new Dictionary<string, object> { ["appName"] = "TestApp" },
+        };
+        if (state != null) evt.Data["state"] = state;
+        return evt;
    }

    [Fact]
@@ -46,6 +46,8 @@ public class FleetHealthPayloadTests
        Assert.Equal(0, payload.Stats.Total);
        Assert.Equal(0d, payload.Stats.SuccessRate);
        Assert.Equal(0, payload.Stats.AvgDurationMinutes);
+        Assert.Equal(0, payload.Stats.MedianDurationMinutes);
+        Assert.Equal(0, payload.Stats.P90DurationMinutes);
        Assert.Empty(payload.FailureReasons);
        Assert.Empty(payload.ModelHealth);
        Assert.Empty(payload.SlowestModels);
@@ -109,6 +111,28 @@ public class FleetHealthPayloadTests

        // (600 + 1200) / 2 / 60 = 15 min.
        Assert.Equal(15, payload.Stats.AvgDurationMinutes);
+        // Same population feeds the percentile stats: sorted [600, 1200].
+        Assert.Equal(10, payload.Stats.MedianDurationMinutes);
+        Assert.Equal(20, payload.Stats.P90DurationMinutes);
+    }
+
+    [Fact]
+    public void MedianDuration_IsRobustAgainstOutliers_ThatDominateTheAverage()
+    {
+        // The card's raison d'être: 8 typical 10-min enrollments plus a 2 h and a 24 h
+        // outlier (overnight ESP / WhiteGlove late user phase). The mean explodes to ~2.7 h
+        // while the median still answers "how long does a typical enrollment take".
+        var sessions = new List<SessionSummary>();
+        for (int i = 0; i < 8; i++)
+            sessions.Add(S(SessionStatus.Succeeded, durationSeconds: 600));
+        sessions.Add(S(SessionStatus.Succeeded, durationSeconds: 7200));
+        sessions.Add(S(SessionStatus.Succeeded, durationSeconds: 86400));
+
+        var payload = MetricsMath.BuildFleetHealthPayload(sessions, days: 7);
+
+        Assert.Equal(164, payload.Stats.AvgDurationMinutes);   // (8*600 + 7200 + 86400) / 10 / 60
+        Assert.Equal(10, payload.Stats.MedianDurationMinutes); // unmoved by the tail
+        Assert.Equal(120, payload.Stats.P90DurationMinutes);   // tail stays visible
    }

    [Fact]
@@ -0,0 +1,222 @@
+using AutopilotMonitor.Functions.Services;
+using AutopilotMonitor.Shared.DataAccess;
+using AutopilotMonitor.Shared.Models;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+
+namespace AutopilotMonitor.Functions.Tests;
+
+/// <summary>
+/// Power watcher analyze rules — pins the firing behaviour of the built-ins that consume the
+/// agent's live <c>power_state_change</c> events (PowerStateWatcherHost):
+///   - ANALYZE-DEV-009 (high): battery crossed the 15% threshold while enrolling on battery.
+///   - ANALYZE-DEV-010 (warning): the device switched from AC to battery mid-enrollment.
+/// Both rules are deliberately single-required-condition: event_data conditions scan events
+/// INDEPENDENTLY (no same-instance join), so a two-condition rule could false-positive across
+/// two different power events. DEV-009 matches the agent-stamped thresholdPercent (only present
+/// on threshold events, value pins the ladder level); DEV-010 matches transition=ac_to_battery.
+/// Also pins that the rule's string "15" compares equal against the agent's numeric payload.
+/// </summary>
+public class PowerStateRuleTests
+{
+    private const string TenantId  = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+    private const string SessionId = "11111111-2222-3333-4444-555555555555";
+
+    [Fact]
+    public async Task ANALYZE_DEV_009_fires_high_on_the_15_percent_threshold_event()
+    {
+        var rule = BuiltInAnalyzeRules.GetAll().First(r => r.RuleId == "ANALYZE-DEV-009");
+        Assert.True(rule.Enabled);
+        Assert.Equal("high", rule.Severity);
+        Assert.False(rule.MarkSessionAsFailedDefault); // environment risk, not a KO verdict
+
+        var events = new List<EnrollmentEvent>
+        {
+            ThresholdCrossed(thresholdPercent: 15, batteryPercent: 13),
+        };
+
+        var outcome = await RunAsync(rule, events);
+
+        var result = Assert.Single(outcome.Results);
+        Assert.Equal("ANALYZE-DEV-009", result.RuleId);
+        Assert.Equal("high", result.Severity);
+
+        // The numeric payload (int 15) must satisfy the rule's string value "15"; field/value on
+        // the matched condition feed the {{thresholdPercent}} interpolation token.
+        var matched = AsDict(result.MatchedConditions["battery_threshold_15"]);
+        Assert.Equal("thresholdPercent", AsString(matched["field"]));
+        Assert.Equal("15", AsString(matched["value"]));
+    }
+
+    [Theory]
+    [InlineData(50)]
+    [InlineData(30)]
+    public async Task ANALYZE_DEV_009_does_not_fire_on_higher_threshold_levels(int level)
+    {
+        var rule = BuiltInAnalyzeRules.GetAll().First(r => r.RuleId == "ANALYZE-DEV-009");
+
+        var events = new List<EnrollmentEvent>
+        {
+            ThresholdCrossed(thresholdPercent: level, batteryPercent: level - 2),
+        };
+
+        var outcome = await RunAsync(rule, events);
+        Assert.Empty(outcome.Results);
+    }
+
+    [Fact]
+    public async Task ANALYZE_DEV_009_does_not_fire_on_a_low_battery_transition_event()
+    {
+        // An ac_to_battery event at 13% carries batteryPercent but NO thresholdPercent — the
+        // agent emits the separate threshold event for that; the rule must not fire early here.
+        var rule = BuiltInAnalyzeRules.GetAll().First(r => r.RuleId == "ANALYZE-DEV-009");
+
+        var events = new List<EnrollmentEvent>
+        {
+            Transition("ac_to_battery", onAcPower: false, batteryPercent: 13),
+        };
+
+        var outcome = await RunAsync(rule, events);
+        Assert.Empty(outcome.Results);
+    }
+
+    [Fact]
+    public async Task ANALYZE_DEV_010_fires_warning_on_ac_to_battery()
+    {
+        var rule = BuiltInAnalyzeRules.GetAll().First(r => r.RuleId == "ANALYZE-DEV-010");
+        Assert.True(rule.Enabled);
+        Assert.Equal("warning", rule.Severity);
+        Assert.False(rule.MarkSessionAsFailedDefault);
+
+        var events = new List<EnrollmentEvent>
+        {
+            Transition("ac_to_battery", onAcPower: false, batteryPercent: 63),
+        };
+
+        var outcome = await RunAsync(rule, events);
+
+        var result = Assert.Single(outcome.Results);
+        Assert.Equal("ANALYZE-DEV-010", result.RuleId);
+        Assert.Equal("warning", result.Severity);
+
+        var matched = AsDict(result.MatchedConditions["switched_to_battery"]);
+        Assert.Equal("transition", AsString(matched["field"]));
+        Assert.Equal("ac_to_battery", AsString(matched["value"]));
+    }
+
+    [Theory]
+    [InlineData("battery_to_ac")]
+    [InlineData("threshold_crossed")]
+    public async Task ANALYZE_DEV_010_does_not_fire_on_other_transitions(string transition)
+    {
+        var rule = BuiltInAnalyzeRules.GetAll().First(r => r.RuleId == "ANALYZE-DEV-010");
+
+        var events = new List<EnrollmentEvent>
+        {
+            Transition(transition, onAcPower: transition == "battery_to_ac", batteryPercent: 40),
+        };
+
+        var outcome = await RunAsync(rule, events);
+        Assert.Empty(outcome.Results);
+    }
+
+    [Fact]
+    public async Task Neither_rule_fires_on_the_startup_power_state_check()
+    {
+        // The one-shot startup probe event (power_state_check) is a different event type and must
+        // not satisfy either rule, even when it reports a low battery on DC power.
+        var rules = BuiltInAnalyzeRules.GetAll()
+            .Where(r => r.RuleId is "ANALYZE-DEV-009" or "ANALYZE-DEV-010").ToList();
+        Assert.Equal(2, rules.Count);
+
+        var events = new List<EnrollmentEvent>
+        {
+            new()
+            {
+                EventId = Guid.NewGuid().ToString(),
+                TenantId = TenantId,
+                SessionId = SessionId,
+                EventType = "power_state_check",
+                Timestamp = DateTime.UtcNow,
+                Sequence = 5,
+                Data = new Dictionary<string, object>
+                {
+                    ["onAcPower"] = false,
+                    ["hasBattery"] = true,
+                    ["batteryPercent"] = 12,
+                    ["isCharging"] = false,
+                },
+            },
+        };
+
+        foreach (var rule in rules)
+        {
+            var outcome = await RunAsync(rule, events);
+            Assert.Empty(outcome.Results);
+        }
+    }
+
+    // ===== Event builders — mirror the PowerStateWatcherHost emit shape =====
+
+    private static EnrollmentEvent ThresholdCrossed(int thresholdPercent, int batteryPercent) => new()
+    {
+        EventId = Guid.NewGuid().ToString(),
+        TenantId = TenantId,
+        SessionId = SessionId,
+        EventType = "power_state_change",
+        Timestamp = DateTime.UtcNow,
+        Sequence = 42,
+        Data = new Dictionary<string, object>
+        {
+            ["transition"] = "threshold_crossed",
+            ["thresholdPercent"] = thresholdPercent,
+            ["onAcPower"] = false,
+            ["batteryPercent"] = batteryPercent,
+            ["isCharging"] = false,
+            ["batteryLifeMinutes"] = 25,
+        }
+    };
+
+    private static EnrollmentEvent Transition(string transition, bool onAcPower, int batteryPercent) => new()
+    {
+        EventId = Guid.NewGuid().ToString(),
+        TenantId = TenantId,
+        SessionId = SessionId,
+        EventType = "power_state_change",
+        Timestamp = DateTime.UtcNow,
+        Sequence = 43,
+        Data = new Dictionary<string, object>
+        {
+            ["transition"] = transition,
+            ["onAcPower"] = onAcPower,
+            ["batteryPercent"] = batteryPercent,
+            ["isCharging"] = onAcPower,
+            ["batteryLifeMinutes"] = 120,
+        }
+    };
+
+    private static Dictionary<string, object> AsDict(object o)
+    {
+        if (o is Dictionary<string, object> d) return d;
+        throw new InvalidOperationException($"Expected Dictionary<string,object>, got {o?.GetType().Name ?? "null"}");
+    }
+
+    private static string AsString(object o) => o?.ToString() ?? string.Empty;
+
+    private static async Task<AnalysisOutcome> RunAsync(AnalyzeRule rule, List<EnrollmentEvent> events)
+    {
+        var ruleRepo = new Mock<IRuleRepository>();
+        ruleRepo.Setup(r => r.GetAnalyzeRulesAsync("global")).ReturnsAsync(new List<AnalyzeRule> { rule });
+        ruleRepo.Setup(r => r.GetAnalyzeRulesAsync(TenantId)).ReturnsAsync(new List<AnalyzeRule>());
+        ruleRepo.Setup(r => r.GetRuleStatesAsync(It.IsAny<string>())).ReturnsAsync(new Dictionary<string, RuleState>());
+        ruleRepo.Setup(r => r.GetRuleResultsAsync(It.IsAny<string>(), It.IsAny<string>())).ReturnsAsync(new List<RuleResult>());
+
+        var sessionRepo = new Mock<ISessionRepository>();
+        sessionRepo.Setup(s => s.GetSessionEventsStrictAsync(TenantId, SessionId, It.IsAny<int>())).ReturnsAsync(events);
+
+        var ruleService = new AnalyzeRuleService(ruleRepo.Object, NullLogger<AnalyzeRuleService>.Instance);
+        var engine = new RuleEngine(ruleService, ruleRepo.Object, sessionRepo.Object, NullLogger<PowerStateRuleTests>.Instance);
+
+        return await engine.AnalyzeSessionAsync(TenantId, SessionId);
+    }
+}
@@ -90,6 +90,7 @@ public class SessionIndexFieldManifestTests
        ["DiagnosticsBlobName"] = "diag-0001.zip",
        ["DiagnosticsBlobDestination"] = "Hosted",
        ["LastEventAt"] = new DateTimeOffset(StartedAt.AddMinutes(44)),
+        ["LastIngestAt"] = new DateTimeOffset(StartedAt.AddMinutes(46)),
        ["ResumedAt"] = new DateTimeOffset(StartedAt.AddMinutes(10)),
        ["StalledAt"] = new DateTimeOffset(StartedAt.AddMinutes(20)),
        ["AvgApiLatencyMs"] = 513.5,
@@ -36,6 +36,8 @@ public class SessionStatsAggregationTests
        Assert.Equal(0, stats.FailedLastNDays);
        Assert.Equal(0, stats.SuccessRatePct);
        Assert.Equal(0, stats.AvgDurationMinutes);
+        Assert.Equal(0, stats.MedianDurationMinutes);
+        Assert.Equal(0, stats.P90DurationMinutes);
        Assert.Equal(0, stats.TotalToday);
        Assert.Equal(0, stats.FailedToday);
    }
@@ -116,6 +118,29 @@ public class SessionStatsAggregationTests

        // (30 + 10) / 2 = 20 minutes
        Assert.Equal(20, stats.AvgDurationMinutes);
+        // Same Succeeded population feeds the percentile stats: sorted [600, 1800].
+        Assert.Equal(10, stats.MedianDurationMinutes);
+        Assert.Equal(30, stats.P90DurationMinutes);
+    }
+
+    [Fact]
+    public void Median_duration_is_robust_against_outliers_that_dominate_the_average()
+    {
+        // 8 typical 10-min enrollments plus a 2 h and a 24 h outlier: the mean explodes
+        // to ~2.7 h while the median still answers "how long does a typical enrollment
+        // take" — the reason the dashboard card leads with the median.
+        var now = DateTime.UtcNow;
+        var sessions = new List<SessionSummary>();
+        for (int i = 0; i < 8; i++)
+            sessions.Add(MakeSession(SessionStatus.Succeeded, now.AddHours(-1), 600));
+        sessions.Add(MakeSession(SessionStatus.Succeeded, now.AddHours(-2), 7200));
+        sessions.Add(MakeSession(SessionStatus.Succeeded, now.AddHours(-3), 86400));
+
+        var stats = TableStorageService.AggregateSessionStats(sessions, days: 7);
+
+        Assert.Equal(164, stats.AvgDurationMinutes);   // (8*600 + 7200 + 86400) / 10 / 60
+        Assert.Equal(10, stats.MedianDurationMinutes); // unmoved by the tail
+        Assert.Equal(120, stats.P90DurationMinutes);   // tail stays visible
    }

    [Fact]
@@ -172,7 +172,9 @@ public class SessionStatsProjectionEquivalenceTests
        Assert.Equal(full.SucceededLastNDays, projected.SucceededLastNDays);
        Assert.Equal(full.FailedLastNDays, projected.FailedLastNDays);
        Assert.Equal(full.SuccessRatePct, projected.SuccessRatePct);
-        Assert.Equal(full.AvgDurationMinutes, projected.AvgDurationMinutes); // the duration-sensitive card
+        Assert.Equal(full.AvgDurationMinutes, projected.AvgDurationMinutes); // duration-sensitive
+        Assert.Equal(full.MedianDurationMinutes, projected.MedianDurationMinutes); // the headline card
+        Assert.Equal(full.P90DurationMinutes, projected.P90DurationMinutes);
        Assert.Equal(full.TotalToday, projected.TotalToday);
        Assert.Equal(full.FailedToday, projected.FailedToday);
    }
@@ -404,10 +404,12 @@ public class TimeAttributionCalculatorTests
        Assert.Equal(0, b.BlockingAppCount);
    }

-    // ── retry: occupancy spans to the LAST terminal event (audit Q1) ────────
+    // ── retry: every ATTEMPT counts as active time, idle gaps between them don't ──
+    // (2026-08 attempt-duration change: per-pass segment pairing replaced the old
+    // first-start → last-terminal hull.)

    [Fact]
-    public void Retry_IntervalRunsFromFirstStart_ToLastTerminalEvent()
+    public void Retry_ActiveSegmentsSummed_GapBetweenAttemptsExcluded()
    {
        var events = new List<EnrollmentEvent>
        {
@@ -426,10 +428,41 @@ public class TimeAttributionCalculatorTests

        AssertExactPartition(b);
        var interval = Assert.Single(b.BlockingApps);
-        // First started (+6m) → LAST terminal (+12m) = 360 s. The payload timing would have
-        // frozen at the first failure (+8m) — event timestamps are the only valid source.
-        Assert.Equal(360, interval.Seconds);
-        Assert.Equal(360, b.EspAppsOccupancySeconds);
+        // Failed attempt (+6m→+8m = 120 s) + retry (+9m→+12m = 180 s) = 300 s active; the
+        // idle minute between the attempts is not this app's time. The failed attempt still
+        // counts — the payload timing would have frozen at the first failure (audit Q1).
+        Assert.Equal(300, interval.Seconds);
+        // Hull endpoints stay first-start → last-terminal for display/what-if.
+        Assert.Equal(T0.AddMinutes(6), interval.StartUtc);
+        Assert.Equal(T0.AddMinutes(12), interval.EndUtc);
+        Assert.Equal(300, b.EspAppsOccupancySeconds);
+    }
+
+    [Fact]
+    public void TwoPasses_OccupancyCountsActiveSegments_NotTheInterPassGap()
+    {
+        // Field case 44862cd3 ("Set TimeZone"): evaluation pass ends Skipped, the real
+        // install runs much later. The app occupies the critical path only while the IME
+        // actively processes it — the gap belongs to whatever installed in between.
+        var events = new List<EnrollmentEvent>
+        {
+            Evt(T0, "agent_started", EnrollmentPhase.DeviceSetup),
+            Evt(T0.AddMinutes(1), "esp_config_detected", data: EspLists(win32Ids: new[] { AppA })),
+            Evt(T0.AddMinutes(2), "esp_phase_changed", EnrollmentPhase.AppsDevice),
+            Evt(T0.AddMinutes(6), "app_install_started", data: AppData(AppA, "App A")),
+            Evt(T0.AddMinutes(7), "app_install_completed", data: AppData(AppA, "App A", "Skipped")),
+            Evt(T0.AddMinutes(40), "app_install_started", data: AppData(AppA, "App A")),  // real install pass
+            Evt(T0.AddMinutes(41), "app_install_completed", data: AppData(AppA, "App A", "Installed")),
+            Evt(T0.AddMinutes(45), "enrollment_complete"),
+        };
+
+        var b = TimeAttributionCalculator.Compute(
+            Input(events, completedAt: T0.AddMinutes(45), durationSeconds: 2700))!;
+
+        AssertExactPartition(b);
+        var interval = Assert.Single(b.BlockingApps);
+        Assert.Equal(120, interval.Seconds);              // 60 s eval + 60 s install — not 2100 s hull
+        Assert.Equal(120, b.EspAppsOccupancySeconds);     // gap not on the critical path either
    }

    // ── reboots: spans from event gaps, never the detection event's stamp ───
@@ -0,0 +1,138 @@
+using AutopilotMonitor.Functions.Services.Vulnerability;
+using AutopilotMonitor.Shared.Models;
+
+namespace AutopilotMonitor.Functions.Tests;
+
+/// <summary>
+/// Pins <see cref="VulnerabilityCorrelateHandler.BuildVulnerabilityReportEvent"/> — the
+/// backend-materialized <c>vulnerability_report</c> event. The load-bearing logic is the
+/// Sequence assignment: the correlation runs async off a queue, so without one the event
+/// defaulted to Sequence 0 and sorted to the TOP of the timeline (a −13m time-jump badge
+/// on a report that actually arrived last). Default is max+1 (sorts LAST, same contract as
+/// BuildSessionTimeoutEvent / BuildAgentEmergencyBreakEvent); WhiteGlove Part 1 instead
+/// anchors at the Part-1 terminal markers so a late Part-1 report can never cross the
+/// web timeline's sequence-based Pre-Provisioning / User Enrollment split and render as
+/// the start of User Enrollment.
+/// </summary>
+public class VulnerabilityReportEventSequenceTests
+{
+    private const string TenantId  = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
+    private const string SessionId = "b2c3d4e5-f6a7-8901-bcde-f12345678901";
+
+    private static readonly DateTime NowUtc = new(2026, 8, 21, 13, 25, 46, DateTimeKind.Utc);
+
+    private static Dictionary<string, object> Report(string risk = "high") => new()
+    {
+        ["scan_summary"] = new Dictionary<string, object> { ["overall_risk"] = risk },
+        ["findings"] = new List<Dictionary<string, object>>(),
+    };
+
+    private static EnrollmentEvent Build(
+        string? phaseLabel, IReadOnlyList<EnrollmentEvent> existing, Dictionary<string, object>? report = null)
+        => VulnerabilityCorrelateHandler.BuildVulnerabilityReportEvent(
+            TenantId, SessionId, report ?? Report(), phaseLabel, existing, NowUtc);
+
+    [Fact]
+    public void NonWhiteGlove_SortsOnePastTheSessionMax()
+    {
+        var existing = new List<EnrollmentEvent>
+        {
+            new() { Sequence = 3 },
+            new() { Sequence = 41 }, // max — even though out of array order
+            new() { Sequence = 17 },
+        };
+
+        Assert.Equal(42, Build(phaseLabel: null, existing).Sequence);
+    }
+
+    [Fact]
+    public void Sequence_IsOne_WhenNoPriorEvents()
+    {
+        Assert.Equal(1, Build(null, new List<EnrollmentEvent>()).Sequence);
+        Assert.Equal(1, Build(null, null!).Sequence);
+    }
+
+    [Fact]
+    public void WhiteGlovePart1_AnchorsAtPart1Markers_NotPastThePart2Boot()
+    {
+        // Part 2 already running when the async Part-1 scan lands. The web split is
+        // agent_started(50) - 1 = 49; max+1 would be 61 and cross it.
+        var existing = new List<EnrollmentEvent>
+        {
+            new() { Sequence = 10, EventType = "esp_phase_changed" },
+            new() { Sequence = 20, EventType = "whiteglove_complete" },
+            new() { Sequence = 30, EventType = "software_inventory_analysis" },
+            new() { Sequence = 40, EventType = "whiteglove_part1_complete" },
+            new() { Sequence = 50, EventType = "agent_started" },        // Part-2 boot
+            new() { Sequence = 60, EventType = "whiteglove_resumed" },
+        };
+
+        var evt = Build("device_setup", existing);
+
+        // Anchored at the highest Part-1 terminal marker; the timestamp tie-break in the
+        // web sort places it right behind that marker, still inside Pre-Provisioning.
+        Assert.Equal(40, evt.Sequence);
+    }
+
+    [Fact]
+    public void WhiteGlovePart1_UsesWhiteGloveComplete_WhenPart1CompleteMarkerMissing()
+    {
+        var existing = new List<EnrollmentEvent>
+        {
+            new() { Sequence = 20, EventType = "whiteglove_complete" },
+            new() { Sequence = 50, EventType = "agent_started" },
+        };
+
+        Assert.Equal(20, Build("device_setup", existing).Sequence);
+    }
+
+    [Fact]
+    public void WhiteGlovePart1_FallsBackToMaxPlusOne_WithoutAnyMarker()
+    {
+        // No marker ⇒ the web derives no split either, so sorting last is safe.
+        var existing = new List<EnrollmentEvent> { new() { Sequence = 7, EventType = "agent_started" } };
+
+        Assert.Equal(8, Build("device_setup", existing).Sequence);
+    }
+
+    [Fact]
+    public void WhiteGlovePart2_SortsOnePastTheSessionMax()
+    {
+        var existing = new List<EnrollmentEvent>
+        {
+            new() { Sequence = 40, EventType = "whiteglove_part1_complete" },
+            new() { Sequence = 90, EventType = "esp_phase_changed" },
+        };
+
+        Assert.Equal(91, Build("user_enrollment", existing).Sequence);
+    }
+
+    [Fact]
+    public void Shape_IsUnchangedByTheSequenceFix()
+    {
+        var evt = Build(null, new List<EnrollmentEvent>());
+
+        Assert.Equal("vulnerability_report", evt.EventType);
+        Assert.Equal(AutopilotMonitor.Shared.Constants.EventTypes.VulnerabilityReport, evt.EventType);
+        Assert.Equal("VulnerabilityCorrelationService", evt.Source);
+        Assert.Equal(EventSeverity.Error, evt.Severity); // risk=high → Error
+        // Non-phase event: must stay Unknown so the UI timeline doesn't render a phantom phase boundary.
+        Assert.Equal(EnrollmentPhase.Unknown, evt.Phase);
+        Assert.Equal(NowUtc, evt.Timestamp);
+        Assert.Equal(TenantId, evt.TenantId);
+        Assert.Equal(SessionId, evt.SessionId);
+        Assert.Equal("Vulnerability scan complete (risk=high).", evt.Message);
+        Assert.Equal(true, evt.Data["reportAvailable"]);
+        Assert.Equal("single", evt.Data["phase"]);
+        Assert.IsType<Dictionary<string, object>>(evt.Data["scan_summary"]);
+    }
+
+    [Fact]
+    public void Data_Phase_CarriesTheLabel()
+    {
+        var existing = new List<EnrollmentEvent> { new() { Sequence = 20, EventType = "whiteglove_complete" } };
+
+        Assert.Equal("device_setup", Build("device_setup", existing).Data["phase"]);
+        Assert.Equal("user_enrollment", Build("user_enrollment", existing).Data["phase"]);
+    }
+}
@@ -137,6 +137,18 @@ namespace AutopilotMonitor.Functions.Functions.Admin

        private async Task<(int deleted, int written, int orphanStatesGcd, int sunsetSkipped)> ReseedGatherAsync(List<AutopilotMonitor.Shared.Models.GatherRule> rules)
        {
+            // Global-partition rules must stay inside the reserved built-in namespace — an ID
+            // outside it (e.g. GATHER-CUSTOM-*) would silently shadow every tenant's same-ID
+            // custom rule at merge time (global wins). Reject instead of import.
+            var rejectedGather = rules.Where(r => !AutopilotMonitor.Shared.Models.RuleIdPolicy.IsReservedBuiltInId(r.RuleId)).ToList();
+            if (rejectedGather.Count > 0)
+            {
+                _logger.LogError(
+                    "GitHub reseed gather: rejected {Count} rule(s) outside the reserved built-in namespace: {Ids}",
+                    rejectedGather.Count, string.Join(", ", rejectedGather.Select(r => r.RuleId)));
+                rules = rules.Except(rejectedGather).ToList();
+            }
+
            var existing = await _ruleRepo.GetGatherRulesAsync("global");
            var newCatalogIds = rules.Select(r => r.RuleId).ToHashSet(System.StringComparer.Ordinal);
            // A rule the deployed binary already ships IDENTICALLY is embedded-provenance; one whose
@@ -199,6 +211,18 @@ namespace AutopilotMonitor.Functions.Functions.Admin

        private async Task<(int deleted, int written, int orphanStatesGcd, int sunsetSkipped)> ReseedAnalyzeAsync(List<AutopilotMonitor.Shared.Models.AnalyzeRule> rules)
        {
+            // Global-partition rules must stay inside the reserved built-in namespace — an ID
+            // outside it (e.g. ANALYZE-CUSTOM-*) would silently shadow every tenant's same-ID
+            // custom rule at merge time (global wins). Reject instead of import.
+            var rejectedAnalyze = rules.Where(r => !AutopilotMonitor.Shared.Models.RuleIdPolicy.IsReservedBuiltInId(r.RuleId)).ToList();
+            if (rejectedAnalyze.Count > 0)
+            {
+                _logger.LogError(
+                    "GitHub reseed analyze: rejected {Count} rule(s) outside the reserved built-in namespace: {Ids}",
+                    rejectedAnalyze.Count, string.Join(", ", rejectedAnalyze.Select(r => r.RuleId)));
+                rules = rules.Except(rejectedAnalyze).ToList();
+            }
+
            var existing = await _ruleRepo.GetAnalyzeRulesAsync("global");
            var newCatalogIds = rules.Select(r => r.RuleId).ToHashSet(System.StringComparer.Ordinal);
            // A rule the deployed binary already ships IDENTICALLY is embedded-provenance; one whose
@@ -513,7 +513,10 @@ namespace AutopilotMonitor.Functions.Functions.Apps
                    exitCode = s.ExitCode,
                    attemptNumber = s.AttemptNumber,
                    startedAt = s.StartedAt,
-                    durationSeconds = s.DurationSeconds
+                    durationSeconds = s.DurationSeconds,
+                    // 2+ = the IME processed this app in multiple passes (device-ESP
+                    // evaluation + real install) — explains a completion far after startedAt.
+                    installPassCount = s.InstallPassCount
                };
            }).ToList();

@@ -274,7 +274,7 @@ namespace AutopilotMonitor.Functions.Functions.Config
            var response = req.CreateResponse(HttpStatusCode.OK);
            await response.WriteAsJsonAsync(new AgentConfigResponse
            {
-                ConfigVersion = 37, // EnableEspContinueAnywayObservation (Continue-Anyway observation mode)
+                ConfigVersion = 38, // Collectors.EnablePowerStateWatcher (live AC/battery watcher)
                UploadIntervalSeconds = Shared.Constants.DefaultUploadIntervalSeconds,
                SelfDestructOnComplete = tenantConfig.SelfDestructOnComplete ?? true,
                KeepLogFile = tenantConfig.KeepLogFile ?? false,
@@ -35,7 +35,12 @@ public sealed class AppVersionDurationRegressionFinding
 /// </list>
 /// Measured population: Succeeded, non-skip terminal state, plausible observed duration
 /// (<see cref="MetricsMath.HasMeasuredDuration"/>), no AppId collision, non-empty
-/// AppVersion. Version ORDER comes from first-seen install time (min StartedAt) — version
+/// AppVersion, and — cutover gate of the 2026-08 attempt-duration change — an
+/// attempt-anchored duration (<c>LastAttemptStartedAt</c> present). Rows from before the
+/// change carry the old full-span semantics; a median over a mixed population would both
+/// mask real regressions (inflated previous vs. attempt-short current) and falsely re-arm
+/// active episodes, so pre-cutover rows are excluded on BOTH sides of every comparison.
+/// Version ORDER comes from first-seen install time (min StartedAt) — version
 /// strings are never sorted lexically ("9.1" vs "2024.10" would lie). "Previous" is the
 /// version with the latest first-seen strictly before the current version's first-seen;
 /// with parallel ring rollouts that can be a concurrently-deployed version — accepted for
@@ -149,6 +154,9 @@ public static class AppVersionRegressionRadar
            if (summary.Status != "Succeeded") continue;
            if (MetricsMath.IsSkipTerminalState(summary)) continue;
            if (!MetricsMath.HasMeasuredDuration(summary)) continue;
+            // Attempt-semantics cutover gate (see class doc): only attempt-anchored rows
+            // enter the duration population, on both sides of every comparison.
+            if (!summary.LastAttemptStartedAt.HasValue) continue;

            if (!groups.TryGetValue(summary.AppName, out var list))
            {
@@ -35,11 +35,14 @@ public static class MetricsMath
    /// <summary>
    /// Upper plausibility bound for an observed install duration: 6 h, the agent's default
    /// max observation lifetime (AgentMaxLifetimeMinutes = 360) — nothing longer can have
-    /// been continuously watched. Rows above it are emission artifacts, not slow installs:
-    /// a batch emission at session end pins CompletedAt far past the real finish (verified
-    /// in production 2026-07-27: app rows carrying 60 175 s in a session whose own wall
-    /// clock was 2 697 s; 490 rows &gt; 6 h overall, worst 117 days — dominating the
-    /// slowest-apps ranking with six-figure averages).
+    /// been continuously watched. Historically this mostly caught full-span pathologies
+    /// (pre-2026-08 rows measured first observation → last terminal across all install
+    /// passes; verified in production 2026-07-27: app rows carrying 60 175 s in a session
+    /// whose own wall clock was 2 697 s; 490 rows &gt; 6 h overall, worst 117 days). Since
+    /// the 2026-08 attempt-duration change DurationSeconds measures the last attempt, so
+    /// far fewer rows trip this bound — it remains as the guard against back-stamped
+    /// completions, where a single ATTEMPT longer than the agent's own lifetime is still
+    /// impossible to have observed.
    /// </summary>
    public const int MaxPlausibleInstallDurationSeconds = 6 * 3600;

@@ -168,14 +171,15 @@ public static class MetricsMath
    /// drained up to 200k raw sessions into the browser and ran these aggregations on the main
    /// thread. Success rate follows the SLA convention: Succeeded / (Succeeded + Failed) — finished
    /// enrollments only, so in-flight sessions and Incomplete (terminal, non-failure) never dilute
-    /// it. Average duration counts every non-in-progress session that carries a positive duration
-    /// (failures included).
+    /// it. Duration stats (average, median, P90) count every non-in-progress session that carries a
+    /// positive duration (failures included); the cards lead with the median because enrollment
+    /// durations are heavily right-skewed and a handful of multi-hour outliers make the mean
+    /// meaningless as a "typical enrollment" answer.
    /// </summary>
    public static FleetHealthMetrics BuildFleetHealthPayload(IReadOnlyList<SessionSummary> sessions, int days)
    {
        int succeeded = 0, failed = 0, inProgress = 0, incomplete = 0;
-        long completedDurationSeconds = 0;
-        int completedWithDurationCount = 0;
+        var completedDurationSeconds = new List<double>();

        foreach (var s in sessions)
        {
@@ -188,12 +192,10 @@ public static class MetricsMath
            }

            if (s.Status != SessionStatus.InProgress && s.DurationSeconds is int d && d > 0)
-            {
-                completedDurationSeconds += d;
-                completedWithDurationCount++;
-            }
+                completedDurationSeconds.Add(d);
        }

+        completedDurationSeconds.Sort(); // Percentile() expects ascending order
        int total = sessions.Count;
        int finished = succeeded + failed;
        var stats = new FleetHealthStats
@@ -204,9 +206,11 @@ public static class MetricsMath
            InProgress = inProgress,
            Incomplete = incomplete,
            SuccessRate = finished > 0 ? Math.Round((double)succeeded / finished * 100, 1) : 0,
-            AvgDurationMinutes = completedWithDurationCount > 0
-                ? (int)Math.Round((double)completedDurationSeconds / completedWithDurationCount / 60.0, MidpointRounding.AwayFromZero)
+            AvgDurationMinutes = completedDurationSeconds.Count > 0
+                ? (int)Math.Round(completedDurationSeconds.Average() / 60.0, MidpointRounding.AwayFromZero)
                : 0,
+            MedianDurationMinutes = SecondsToMinutes(Percentile(completedDurationSeconds, 50)),
+            P90DurationMinutes = SecondsToMinutes(Percentile(completedDurationSeconds, 90)),
        };

        return new FleetHealthMetrics
@@ -369,6 +373,10 @@ public static class MetricsMath
    /// rounded to one decimal place. Callers MUST pass values pre-sorted ascending.
    /// Returns 0 for an empty list.
    /// </summary>
+    /// <summary>Rounds a duration in seconds to whole minutes (away from zero, matching the avg).</summary>
+    public static int SecondsToMinutes(double seconds)
+        => (int)Math.Round(seconds / 60.0, MidpointRounding.AwayFromZero);
+
    public static double Percentile(List<double> sortedValues, int percentile)
    {
        if (sortedValues.Count == 0) return 0;
@@ -111,6 +111,10 @@ public static class TimeAttributionCalculator
        public string AppName = string.Empty;
        public DateTime? FirstStart;
        public DateTime? LastTerminal;
+        /// <summary>Start of the currently open activity segment (start seen, terminal pending).</summary>
+        public DateTime? OpenStart;
+        /// <summary>Closed activity segments: one per fully-observed install pass/attempt (start → terminal).</summary>
+        public List<(DateTime Start, DateTime End)> Segments = new();
    }

    /// <summary>
@@ -152,13 +156,15 @@ public static class TimeAttributionCalculator
        else if (blockingSets.IsTruncated)
            flags |= TimeAttributionFlags.BlockingSetTruncated;

-        var (blockingApps, blockingAppCount) = BuildBlockingAppIntervals(events, blockingSets, windows, ref flags);
+        var (blockingApps, blockingAppCount, blockingAppSegments) = BuildBlockingAppIntervals(events, blockingSets, windows, ref flags);

        int? occupancy = null;
        if (blockingSets != null && blockingSets.ListedCount > 0)
        {
            var espAppsSpans = spans.Where(s => s.SegmentKey == TimeAttributionSegments.EspApps).ToList();
-            occupancy = ComputeOccupancySeconds(blockingApps, espAppsSpans);
+            // Occupancy merges the per-pass SEGMENTS, not the per-app hulls — a hull spans
+            // the idle gap between install passes, which is not occupied by this app.
+            occupancy = ComputeOccupancySeconds(blockingAppSegments, espAppsSpans);
        }

        var rebootSpans = BuildRebootSpans(events, windows, spans);
@@ -403,12 +409,12 @@ public static class TimeAttributionCalculator

    // ── blocking-app intervals + occupancy ──────────────────────────────────

-    private static (List<BlockingAppInterval> Intervals, int MatchedCount) BuildBlockingAppIntervals(
+    private static (List<BlockingAppInterval> Intervals, int MatchedCount, List<BlockingAppInterval> OccupancySegments) BuildBlockingAppIntervals(
        List<EnrollmentEvent> events, EspBlockingSets? sets, List<Window> windows, ref TimeAttributionFlags flags)
    {
        var intervals = new List<BlockingAppInterval>();
        if (sets == null || sets.ListedCount == 0)
-            return (intervals, 0);
+            return (intervals, 0, intervals);

        // Fold per-app activity from EVENT timestamps (never payload timing — audit Q1).
        var apps = new Dictionary<string, AppActivity>(StringComparer.OrdinalIgnoreCase);
@@ -436,36 +442,75 @@ public static class TimeAttributionCalculator
                activity.AppName = nameObj?.ToString()?.Trim() ?? string.Empty;
            }

-            if (isStart && (!activity.FirstStart.HasValue || evt.Timestamp < activity.FirstStart.Value))
-                activity.FirstStart = evt.Timestamp;
-            // LAST terminal wins — an IME retry (Error → retry → Installed) extends the
-            // occupancy to the final outcome instead of freezing at the first failure.
-            if (isTerminal && (!activity.LastTerminal.HasValue || evt.Timestamp > activity.LastTerminal.Value))
-                activity.LastTerminal = evt.Timestamp;
+            if (isStart)
+            {
+                if (!activity.FirstStart.HasValue || evt.Timestamp < activity.FirstStart.Value)
+                    activity.FirstStart = evt.Timestamp;
+                // A download start followed by an install start is ONE active window —
+                // the earliest open start survives until a terminal closes the segment.
+                activity.OpenStart ??= evt.Timestamp;
+            }
+            if (isTerminal)
+            {
+                if (!activity.LastTerminal.HasValue || evt.Timestamp > activity.LastTerminal.Value)
+                    activity.LastTerminal = evt.Timestamp;
+                // Segment pairing (2026-08 attempt-duration change): each fully-observed
+                // pass/attempt (start → terminal, sequence-ordered) is its own activity
+                // segment. The IME processes the app list in multiple passes; the idle gap
+                // between passes belongs to the apps actually running then, not to this one.
+                // A failed attempt still counts as active time — the retry opens a new
+                // segment, so the old "LAST terminal wins" retry intent is preserved.
+                if (activity.OpenStart.HasValue)
+                {
+                    if (evt.Timestamp >= activity.OpenStart.Value)
+                        activity.Segments.Add((activity.OpenStart.Value, evt.Timestamp));
+                    else
+                        flags |= TimeAttributionFlags.ClockSkewDropped;
+                    activity.OpenStart = null;
+                }
+                // Terminal without an observed start: no segment claim (attach window,
+                // audit §0.5) — same rule as before.
+            }
        }

        var matched = 0;
+        var occupancySegments = new List<BlockingAppInterval>();
        foreach (var activity in apps.Values)
        {
            if (!sets.Contains(activity.AppId)) continue; // absent ⇒ unknown, never "not blocking"
            matched++;

-            if (!activity.FirstStart.HasValue || !activity.LastTerminal.HasValue)
-                continue; // unobserved endpoint → no interval claim (attach window, audit §0.5)
-            if (activity.LastTerminal.Value < activity.FirstStart.Value)
-            {
-                flags |= TimeAttributionFlags.ClockSkewDropped;
-                continue;
-            }
+            if (activity.Segments.Count == 0)
+                continue; // no fully-observed attempt → no interval claim (attach window, audit §0.5)

-            var clamped = ClampToWindows(activity.FirstStart.Value, activity.LastTerminal.Value, windows);
-            if (!clamped.HasValue)
+            // Clamp each segment; the persisted per-app interval is the hull of the clamped
+            // segments with Seconds = the SUM of in-window active time (not the hull span —
+            // the inter-pass idle gap is not this app's time).
+            var total = 0;
+            DateTime? hullStart = null, hullEnd = null;
+            foreach (var segment in activity.Segments)
            {
-                // Outside the hull entirely → pathological timestamps (flagged, as before).
-                // Inside the hull but touching no window (wholly inside the WhiteGlove pause):
-                // no in-window observation → no interval claim, and nothing wrong with clocks.
-                if (activity.LastTerminal.Value < windows[0].Start ||
-                    activity.FirstStart.Value > windows[windows.Count - 1].End)
+                var clamped = ClampToWindows(segment.Start, segment.End, windows);
+                if (!clamped.HasValue) continue;
+                total += clamped.Value.Seconds;
+                if (hullStart == null || clamped.Value.Start < hullStart.Value) hullStart = clamped.Value.Start;
+                if (hullEnd == null || clamped.Value.End > hullEnd.Value) hullEnd = clamped.Value.End;
+                occupancySegments.Add(new BlockingAppInterval
+                {
+                    AppId = activity.AppId,
+                    AppName = activity.AppName,
+                    StartUtc = clamped.Value.Start,
+                    EndUtc = clamped.Value.End,
+                    Seconds = clamped.Value.Seconds,
+                });
+            }
+            if (hullStart == null || hullEnd == null)
+            {
+                // No segment overlapped any window. Outside the hull entirely →
+                // pathological timestamps (flagged, as before). Wholly inside the
+                // WhiteGlove pause → no in-window observation, nothing wrong with clocks.
+                if (activity.LastTerminal!.Value < windows[0].Start ||
+                    activity.FirstStart!.Value > windows[windows.Count - 1].End)
                {
                    flags |= TimeAttributionFlags.ClockSkewDropped;
                }
@@ -476,14 +521,13 @@ public static class TimeAttributionCalculator
            {
                AppId = activity.AppId,
                AppName = activity.AppName,
-                StartUtc = clamped.Value.Start,
-                EndUtc = clamped.Value.End,
-                // In-window seconds — a WG-pause-straddling interval never counts the pause.
-                Seconds = clamped.Value.Seconds,
+                StartUtc = hullStart.Value,
+                EndUtc = hullEnd.Value,
+                Seconds = total,
            });
        }

-        return (intervals, matched);
+        return (intervals, matched, occupancySegments);
    }

    /// <summary>
@@ -289,10 +289,16 @@ namespace AutopilotMonitor.Functions.Services.Analyze
                        rule.Title, rule.Category, rule.Severity,
                        fired, confidence).ConfigureAwait(false);

-                    await _metricsRepo.IncrementRuleStatAsync(
-                        today, "global", rule.RuleId, "analyze",
-                        rule.Title, rule.Category, rule.Severity,
-                        fired, confidence).ConfigureAwait(false);
+                    // Global aggregate row is catalog-only: custom-rule IDs are tenant-chosen
+                    // and not unique across tenants, so a shared "global_{ruleId}" row would
+                    // sum unrelated tenants' counters (title/severity last-writer-wins).
+                    if (rule.IsBuiltIn || rule.IsCommunity)
+                    {
+                        await _metricsRepo.IncrementRuleStatAsync(
+                            today, "global", rule.RuleId, "analyze",
+                            rule.Title, rule.Category, rule.Severity,
+                            fired, confidence).ConfigureAwait(false);
+                    }
                }
            }
            catch (Exception ex)
@@ -112,6 +112,22 @@ namespace AutopilotMonitor.Functions.Services
                case "app_install_start":
                    if (!state.InstallStartedAt.HasValue || evt.Timestamp < state.InstallStartedAt.Value)
                        state.InstallStartedAt = evt.Timestamp;
+                    // Attempt anchor: the LATEST start wins (max-fold). DurationSeconds
+                    // measures the status-defining attempt, not the session-wide span — the
+                    // IME processes the app list in multiple passes (device-ESP evaluation,
+                    // user-context install, retries), often an hour apart.
+                    if (!summary.LastAttemptStartedAt.HasValue || evt.Timestamp > summary.LastAttemptStartedAt.Value)
+                        summary.LastAttemptStartedAt = evt.Timestamp;
+                    summary.InstallPassCount++;
+                    // Attempt-scoped download pairing: a pending download start is consumed
+                    // by the next install start of the same app.
+                    if (state.PendingDownloadStartedAt.HasValue && evt.Timestamp >= state.PendingDownloadStartedAt.Value)
+                    {
+                        var pairedDl = EventTimestampValidator.SafeDurationSeconds(state.PendingDownloadStartedAt.Value, evt.Timestamp);
+                        if (pairedDl > 0)
+                            summary.DownloadDurationSeconds = pairedDl;
+                        state.PendingDownloadStartedAt = null;
+                    }
                    if (summary.Status == "InProgress" || summary.Status == string.Empty)
                        summary.Status = "InProgress";
                    break;
@@ -119,34 +135,48 @@ namespace AutopilotMonitor.Functions.Services
                case "app_download_started":
                    if (!state.DownloadStartedAt.HasValue || evt.Timestamp < state.DownloadStartedAt.Value)
                        state.DownloadStartedAt = evt.Timestamp;
+                    // Latest unconsumed download start — pairs with the NEXT install start.
+                    if (!state.PendingDownloadStartedAt.HasValue || evt.Timestamp > state.PendingDownloadStartedAt.Value)
+                        state.PendingDownloadStartedAt = evt.Timestamp;
                    if (summary.Status == "InProgress" || summary.Status == string.Empty)
                        summary.Status = "InProgress";
                    break;

                case "app_install_completed":
                case "app_install_complete":
+                    // A weaker terminal (Skipped/Postponed re-evaluation pass) never overrides
+                    // an Installed/Error already observed — mirrors the app_install_skipped
+                    // guard below. It must not move CompletedAt/DurationSeconds either: the
+                    // row keeps describing the attempt that produced the surviving terminal.
+                    var incomingTerminalState = evt.Data?.ContainsKey("state") == true
+                        ? evt.Data["state"]?.ToString() : null;
+                    if ((summary.TerminalState == "Installed" || summary.TerminalState == "Error") &&
+                        (incomingTerminalState == "Skipped" || incomingTerminalState == "Postponed"))
+                        break;
                    summary.Status = "Succeeded";
                    summary.CompletedAt = evt.Timestamp;
-                    if (summary.StartedAt != DateTime.MinValue)
-                        summary.DurationSeconds = Math.Max(1, EventTimestampValidator.SafeDurationSeconds(summary.StartedAt, evt.Timestamp));
+                    var attemptStart = summary.LastAttemptStartedAt
+                        ?? (summary.StartedAt != DateTime.MinValue ? summary.StartedAt : (DateTime?)null);
+                    if (attemptStart.HasValue)
+                        summary.DurationSeconds = Math.Max(1, EventTimestampValidator.SafeDurationSeconds(attemptStart.Value, evt.Timestamp));
                    // PR0 (2026-07-26): the agent emits app_install_completed for EVERY terminal
                    // transition — including Skipped/Postponed (V1 wire parity). The payload's
                    // `state` field is the only way to tell a real install apart from a no-op
                    // (e.g. WinGet "Update for X" policies that were not applicable). Persist it
                    // so metrics can exclude skips from durations and rates. Unknown/absent state
                    // leaves the sentinel empty — never guessed.
-                    var terminalStateRaw = evt.Data?.ContainsKey("state") == true
-                        ? evt.Data["state"]?.ToString() : null;
-                    if (terminalStateRaw == "Installed" || terminalStateRaw == "Skipped" || terminalStateRaw == "Postponed")
-                        summary.TerminalState = terminalStateRaw;
+                    if (incomingTerminalState == "Installed" || incomingTerminalState == "Skipped" || incomingTerminalState == "Postponed")
+                        summary.TerminalState = incomingTerminalState;
                    break;

                case "app_install_failed":
                    summary.Status = "Failed";
                    summary.TerminalState = "Error";
                    summary.CompletedAt = evt.Timestamp;
-                    if (summary.StartedAt != DateTime.MinValue)
-                        summary.DurationSeconds = Math.Max(1, EventTimestampValidator.SafeDurationSeconds(summary.StartedAt, evt.Timestamp));
+                    var failedAttemptStart = summary.LastAttemptStartedAt
+                        ?? (summary.StartedAt != DateTime.MinValue ? summary.StartedAt : (DateTime?)null);
+                    if (failedAttemptStart.HasValue)
+                        summary.DurationSeconds = Math.Max(1, EventTimestampValidator.SafeDurationSeconds(failedAttemptStart.Value, evt.Timestamp));
                    // FailureCode preference: canonical `failureType` > raw `errorCode` > empty.
                    // c117946b debrief (2026-05-12): the V2 termination handler tags promoted
                    // "likely stuck" apps with failureType=esp_apps_timeout so the UI can
@@ -310,20 +340,30 @@ namespace AutopilotMonitor.Functions.Services
                summary.StartedAt = effectiveStart;
            }

-            // Download duration: from first download start to first install start.
-            if (state.DownloadStartedAt.HasValue && state.InstallStartedAt.HasValue &&
-                state.InstallStartedAt.Value >= state.DownloadStartedAt.Value)
-            {
-                summary.DownloadDurationSeconds = EventTimestampValidator.SafeDurationSeconds(
-                    state.DownloadStartedAt.Value, state.InstallStartedAt.Value);
-            }
+            // Download duration is paired attempt-scoped at the app_install_started event
+            // (latest download start → next install start) — no span computation here.

-            // Full duration: from effective start to completion/failure.
-            if (summary.CompletedAt.HasValue && summary.StartedAt != DateTime.MinValue &&
-                summary.CompletedAt.Value >= summary.StartedAt)
+            // Full duration: the status-defining attempt. CompletedAt pairs with the latest
+            // attempt start at or before it. A LastAttemptStartedAt NEWER than CompletedAt
+            // means a fresh pass is in flight — the recorded duration of the completed
+            // attempt stands. Rows without any observed start (legacy agents, terminal-only
+            // batches) keep the historical StartedAt (span) fallback.
+            if (summary.CompletedAt.HasValue)
            {
-                summary.DurationSeconds = EventTimestampValidator.SafeDurationSeconds(
-                    summary.StartedAt, summary.CompletedAt.Value);
+                if (summary.LastAttemptStartedAt.HasValue)
+                {
+                    if (summary.LastAttemptStartedAt.Value <= summary.CompletedAt.Value)
+                    {
+                        summary.DurationSeconds = EventTimestampValidator.SafeDurationSeconds(
+                            summary.LastAttemptStartedAt.Value, summary.CompletedAt.Value);
+                    }
+                }
+                else if (summary.StartedAt != DateTime.MinValue &&
+                         summary.CompletedAt.Value >= summary.StartedAt)
+                {
+                    summary.DurationSeconds = EventTimestampValidator.SafeDurationSeconds(
+                        summary.StartedAt, summary.CompletedAt.Value);
+                }
            }
        }
    }
@@ -333,5 +373,7 @@ namespace AutopilotMonitor.Functions.Services
        public AppInstallSummary Summary { get; set; } = new();
        public DateTime? DownloadStartedAt { get; set; }
        public DateTime? InstallStartedAt { get; set; }
+        /// <summary>Latest download start not yet consumed by an install start (attempt-scoped download-duration pairing).</summary>
+        public DateTime? PendingDownloadStartedAt { get; set; }
    }
 }
@@ -378,6 +378,9 @@ namespace AutopilotMonitor.Functions.Services
            "stall_probe_result" => true,
            "session_stalled" => true,
            "modern_deployment_log" => true,
+            // Environment observation (battery drain / AC flap), not enrollment progress —
+            // must not count as "real activity" that heals a Stalled session.
+            "power_state_change" => true,
            _ => false
        };

@@ -36,10 +36,18 @@ namespace AutopilotMonitor.Functions.Services
                        ruleTitle, "", "",
                        fired: true, confidenceScore: null);

-                    await _metricsRepo.IncrementRuleStatAsync(
-                        today, "global", ruleId, "gather",
-                        ruleTitle, "", "",
-                        fired: true, confidenceScore: null);
+                    // Global aggregate row is catalog-only. The agent event carries no
+                    // IsBuiltIn flag, but custom rules can never occupy the reserved
+                    // built-in namespace (create/update guard), so the ID pattern is the
+                    // discriminator. Custom IDs are tenant-chosen and not unique across
+                    // tenants — a shared "global_{ruleId}" row would mix their counters.
+                    if (RuleIdPolicy.IsReservedBuiltInId(ruleId))
+                    {
+                        await _metricsRepo.IncrementRuleStatAsync(
+                            today, "global", ruleId, "gather",
+                            ruleTitle, "", "",
+                            fired: true, confidenceScore: null);
+                    }
                }
            }
            catch (Exception ex)
@@ -78,6 +78,7 @@ namespace AutopilotMonitor.Functions.Services
            "DiagnosticsBlobName",
            "DiagnosticsBlobDestination",
            "LastEventAt",
+            "LastIngestAt",
            "ResumedAt",
            "StalledAt",
            "AvgApiLatencyMs",
@@ -260,29 +260,75 @@ namespace AutopilotMonitor.Functions.Services
                    var existingStartedAt = existing.GetDateTimeOffset("StartedAt")?.UtcDateTime;
                    if (existingStartedAt.HasValue && existingStartedAt.Value != DateTime.MinValue)
                    {
-                        // Keep the earlier StartedAt; recalculate duration if CompletedAt is now known
+                        // Keep the earlier StartedAt — it is the window/bucket filter column and
+                        // the radar's version-ordering key, never re-anchored to a later attempt.
+                        // Duration recompute happens attempt-aware further down.
                        if (summary.StartedAt == DateTime.MinValue || existingStartedAt.Value < summary.StartedAt)
-                        {
                            summary.StartedAt = existingStartedAt.Value;
-                            if (summary.CompletedAt.HasValue && summary.CompletedAt.Value >= summary.StartedAt)
-                            {
-                                summary.DurationSeconds = (int)(summary.CompletedAt.Value - summary.StartedAt).TotalSeconds;
-                            }
-                        }
+                    }
+
+                    // Attempt anchor: the LATEST start wins across batches (mirror of the
+                    // in-batch max-fold — a replayed older batch can never regress it), and the
+                    // pass counter only grows when the batch carries genuinely newer starts
+                    // (replay guard: a batch whose newest start is not newer than the stored
+                    // anchor was already counted).
+                    var existingLastAttempt = existing.GetDateTimeOffset("LastAttemptStartedAt")?.UtcDateTime;
+                    var existingPassCount = existing.GetInt32("InstallPassCount") ?? 0;
+                    if (summary.LastAttemptStartedAt.HasValue &&
+                        (!existingLastAttempt.HasValue || summary.LastAttemptStartedAt.Value > existingLastAttempt.Value))
+                    {
+                        summary.InstallPassCount += existingPassCount;
+                    }
+                    else
+                    {
+                        summary.InstallPassCount = Math.Max(summary.InstallPassCount, existingPassCount);
+                        if (existingLastAttempt.HasValue)
+                            summary.LastAttemptStartedAt = existingLastAttempt;
+                    }
+
+                    // Cross-batch mirror of the weaker-terminal guard: a batch that only saw a
+                    // Skipped/Postponed re-evaluation pass never overrides a stored
+                    // Installed/Error, and its CompletedAt/DurationSeconds must not re-describe
+                    // the row (nulling them omits the columns → Merge preserves the stored
+                    // values of the surviving attempt).
+                    var existingTerminalStateForGuard = existing.GetString("TerminalState");
+                    if ((existingTerminalStateForGuard == "Installed" || existingTerminalStateForGuard == "Error") &&
+                        (summary.TerminalState == "Skipped" || summary.TerminalState == "Postponed"))
+                    {
+                        summary.TerminalState = existingTerminalStateForGuard!;
+                        if (existingStatus == "Succeeded" || existingStatus == "Failed")
+                            summary.Status = existingStatus!;
+                        summary.CompletedAt = null;
+                        summary.DurationSeconds = 0;
                    }

                    // Q4 (source-data audit 2026-07-26): out-of-order arrival — the terminal batch
-                    // landed FIRST (row already carries CompletedAt), the started batch arrives now
-                    // with the earlier StartedAt. Neither batch alone could compute the duration;
-                    // recompute it here against the stored CompletedAt so the row doesn't keep a
-                    // permanently unset duration despite both endpoints being known.
+                    // landed FIRST (row already carries CompletedAt), the started batch arrives now.
+                    // Neither batch alone could compute the duration; adopt the stored CompletedAt
+                    // so the attempt-aware recompute below can pair both endpoints.
                    if (!summary.CompletedAt.HasValue && summary.StartedAt != DateTime.MinValue)
                    {
                        var existingCompletedAt = existing.GetDateTimeOffset("CompletedAt")?.UtcDateTime;
                        if (existingCompletedAt.HasValue && existingCompletedAt.Value >= summary.StartedAt)
-                        {
                            summary.CompletedAt = existingCompletedAt.Value;
-                            summary.DurationSeconds = (int)(existingCompletedAt.Value - summary.StartedAt).TotalSeconds;
+                    }
+
+                    // Attempt-aware duration recompute — single site for both endpoints-known
+                    // paths (in-order and Q4 out-of-order). Anchor = latest attempt start at or
+                    // before CompletedAt; rows without an observed start keep the historical
+                    // StartedAt (span) fallback. A LastAttemptStartedAt NEWER than CompletedAt
+                    // means a fresh pass is in flight — the stored duration of the completed
+                    // attempt stands (DurationSeconds 0 omits the column, Merge preserves it).
+                    if (summary.CompletedAt.HasValue)
+                    {
+                        if (summary.LastAttemptStartedAt.HasValue)
+                        {
+                            if (summary.LastAttemptStartedAt.Value <= summary.CompletedAt.Value)
+                                summary.DurationSeconds = (int)(summary.CompletedAt.Value - summary.LastAttemptStartedAt.Value).TotalSeconds;
+                        }
+                        else if (summary.StartedAt != DateTime.MinValue && summary.CompletedAt.Value >= summary.StartedAt)
+                        {
+                            summary.DurationSeconds = (int)(summary.CompletedAt.Value - summary.StartedAt).TotalSeconds;
                        }
                    }

@@ -571,7 +617,10 @@ namespace AutopilotMonitor.Functions.Services
            "PartitionKey", "RowKey", "TenantId", "SessionId", "AppName", "AppType", "AppVersion",
            "Status", "TerminalState", "StartedAt", "CompletedAt", "DurationSeconds", "DownloadBytes",
            "AttemptNumber", "InstallerPhase", "FailureCode", "FailureMessage", "ExitCode", "DetectionResult",
-            "AppId", "EspBlocking", "AppIdCollision"
+            "AppId", "EspBlocking", "AppIdCollision",
+            // Attempt-duration columns (2026-08): the radar's cutover gate reads the anchor,
+            // the dashboard sessions table shows the pass count.
+            "LastAttemptStartedAt", "InstallPassCount"
        };

        /// <summary>
@@ -671,6 +720,8 @@ namespace AutopilotMonitor.Functions.Services
                FailureMessage = entity.GetString("FailureMessage") ?? string.Empty,
                StartedAt = entity.GetDateTimeOffset("StartedAt")?.UtcDateTime ?? DateTime.MinValue,
                CompletedAt = entity.GetDateTimeOffset("CompletedAt")?.UtcDateTime,
+                LastAttemptStartedAt = entity.GetDateTimeOffset("LastAttemptStartedAt")?.UtcDateTime,
+                InstallPassCount = entity.GetInt32("InstallPassCount") ?? 0,
                // Delivery Optimization telemetry
                DoFileSize = entity.GetInt64("DoFileSize") ?? 0,
                DoTotalBytesDownloaded = entity.GetInt64("DoTotalBytesDownloaded") ?? 0,
@@ -1563,6 +1614,12 @@ namespace AutopilotMonitor.Functions.Services
                entity["DurationSeconds"] = summary.DurationSeconds;
            if (summary.CompletedAt.HasValue)
                entity["CompletedAt"] = EnsureUtc(summary.CompletedAt.Value);
+            // Attempt-duration columns (2026-08): both sentinel-gated — a batch that observed
+            // no install start must not clobber the stored anchor/counter under Merge-mode.
+            if (summary.LastAttemptStartedAt.HasValue)
+                entity["LastAttemptStartedAt"] = EnsureUtc(summary.LastAttemptStartedAt.Value);
+            if (summary.InstallPassCount > 0)
+                entity["InstallPassCount"] = summary.InstallPassCount;
            if (!string.IsNullOrEmpty(summary.FailureCode))
                entity["FailureCode"] = summary.FailureCode;
            if (!string.IsNullOrEmpty(summary.FailureMessage))
@@ -442,6 +442,20 @@ namespace AutopilotMonitor.Functions.Services
        public async Task<(int deleted, int failed)> DeleteRuleStatesForRuleIdAcrossTenantsAsync(string ruleId)
        {
            if (string.IsNullOrWhiteSpace(ruleId)) return (0, 0);
+
+            // This is a cross-partition delete keyed on a bare RowKey string, so only
+            // catalog (built-in/community) IDs may pass: custom-rule IDs are tenant-chosen
+            // and not unique across tenants, and a call with one would delete state rows
+            // of unrelated tenants. failed=-1 reuses the enumeration-failure contract —
+            // the caller then refuses the follow-up global catalog delete.
+            if (!RuleIdPolicy.IsReservedBuiltInId(ruleId))
+            {
+                _logger.LogError(
+                    "Refusing cross-tenant RuleState GC for '{RuleId}': ID is outside the reserved built-in namespace",
+                    ruleId);
+                return (0, -1);
+            }
+
            try
            {
                var tableClient = _tableServiceClient.GetTableClient(Constants.TableNames.RuleStates);
@@ -225,6 +225,13 @@ namespace AutopilotMonitor.Functions.Services
            if (lastEventAt.HasValue)
                indexEntity["LastEventAt"] = EnsureUtc(lastEventAt.Value);

+            // Server-frame ingest stamp (IncrementSessionEventCountAsync merges this on every
+            // batch, so the index already carries it) — must be in this superset or a
+            // StartedAt-shift full upsert drops it and index-served reads lose the field.
+            var lastIngestAt = sessionEntity.GetDateTimeOffset("LastIngestAt")?.UtcDateTime;
+            if (lastIngestAt.HasValue)
+                indexEntity["LastIngestAt"] = EnsureUtc(lastIngestAt.Value);
+
            var resumedAt = sessionEntity.GetDateTimeOffset("ResumedAt")?.UtcDateTime;
            if (resumedAt.HasValue)
                indexEntity["ResumedAt"] = EnsureUtc(resumedAt.Value);
@@ -1223,8 +1230,7 @@ namespace AutopilotMonitor.Functions.Services
            int succeeded = 0;
            int failed = 0;
            int incomplete = 0;
-            long succeededDurationSeconds = 0;
-            int succeededWithDurationCount = 0;
+            var succeededDurationSeconds = new List<double>();
            int totalToday = 0;
            int failedToday = 0;

@@ -1243,10 +1249,7 @@ namespace AutopilotMonitor.Functions.Services
                    case SessionStatus.Succeeded:
                        succeeded++;
                        if (s.DurationSeconds is int d && d > 0)
-                        {
-                            succeededDurationSeconds += d;
-                            succeededWithDurationCount++;
-                        }
+                            succeededDurationSeconds.Add(d);
                        break;
                    case SessionStatus.Failed:
                        failed++;
@@ -1268,8 +1271,9 @@ namespace AutopilotMonitor.Functions.Services
            int successRatePct = terminal > 0
                ? (int)Math.Round((double)succeeded / terminal * 100.0)
                : 0;
-            int avgDurationMinutes = succeededWithDurationCount > 0
-                ? (int)Math.Round((double)succeededDurationSeconds / succeededWithDurationCount / 60.0)
+            succeededDurationSeconds.Sort(); // MetricsMath.Percentile expects ascending order
+            int avgDurationMinutes = succeededDurationSeconds.Count > 0
+                ? (int)Math.Round(succeededDurationSeconds.Average() / 60.0)
                : 0;

            return new SessionStats
@@ -1282,6 +1286,8 @@ namespace AutopilotMonitor.Functions.Services
                IncompleteLastNDays = incomplete,
                SuccessRatePct = successRatePct,
                AvgDurationMinutes = avgDurationMinutes,
+                MedianDurationMinutes = MetricsMath.SecondsToMinutes(MetricsMath.Percentile(succeededDurationSeconds, 50)),
+                P90DurationMinutes = MetricsMath.SecondsToMinutes(MetricsMath.Percentile(succeededDurationSeconds, 90)),
                TotalToday = totalToday,
                FailedToday = failedToday,
                ComputedAt = DateTime.UtcNow,
@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using AutopilotMonitor.Functions.Services.Analyze;
+using AutopilotMonitor.Shared;
 using AutopilotMonitor.Shared.DataAccess;
 using AutopilotMonitor.Shared.Models;
 using Microsoft.Extensions.Logging;
@@ -255,36 +256,23 @@ namespace AutopilotMonitor.Functions.Services.Vulnerability
        {
            try
            {
-                var scanSummary = reportData.TryGetValue("scan_summary", out var summaryObj)
-                    && summaryObj is Dictionary<string, object> summaryDict
-                    ? summaryDict
-                    : new Dictionary<string, object>();
+                // Soft read: a storage hiccup degrades the event to Sequence 1 instead of
+                // suppressing it entirely — the downstream re-analyze (ANALYZE-ID-003) needs
+                // the event to exist more than it needs a perfect timeline position.
+                var existingEvents = await _sessionRepo
+                    .GetSessionEventsAsync(tenantId, sessionId).ConfigureAwait(false);

-                var overallRisk = scanSummary.TryGetValue("overall_risk", out var riskObj)
-                    ? riskObj?.ToString()
-                    : null;
-
-                var data = new Dictionary<string, object>(StringComparer.Ordinal)
-                {
-                    ["scan_summary"] = scanSummary,
-                    ["reportAvailable"] = true,
-                    ["phase"] = phaseLabel ?? "single",
-                };
-
-                var evt = new EnrollmentEvent
-                {
-                    TenantId = tenantId,
-                    SessionId = sessionId,
-                    EventType = "vulnerability_report",
-                    Severity = MapVulnerabilityRiskToSeverity(overallRisk),
-                    Source = "VulnerabilityCorrelationService",
-                    Phase = EnrollmentPhase.Unknown,
-                    Message = $"Vulnerability scan complete (risk={overallRisk ?? "unknown"}).",
-                    Timestamp = DateTime.UtcNow,
-                    Data = data,
-                };
+                var evt = BuildVulnerabilityReportEvent(
+                    tenantId, sessionId, reportData, phaseLabel, existingEvents, DateTime.UtcNow);

                await _sessionRepo.StoreEventsBatchAsync(new List<EnrollmentEvent> { evt }).ConfigureAwait(false);
+
+                // StoreEventsBatchAsync writes the Events partition only; the cross-session
+                // EventType index is normally written by EventIngestProcessor, which this
+                // backend-materialized event never passes through (see the identical upsert in
+                // ReportAgentErrorFunction for the incident that established the pattern).
+                await _sessionRepo.UpsertEventTypeIndexBatchAsync(
+                    tenantId, sessionId, new List<EnrollmentEvent> { evt }).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
@@ -293,6 +281,84 @@ namespace AutopilotMonitor.Functions.Services.Vulnerability
            }
        }

+        /// <summary>
+        /// Builds the synthetic <c>vulnerability_report</c> timeline event. Static + pure
+        /// (analog to <c>ReportAgentErrorFunction.BuildAgentEmergencyBreakEvent</c>) so the
+        /// field shape and the Sequence assignment are unit-testable.
+        /// <para>
+        /// <b>Sequence:</b> the correlation runs async off a queue, so the event arrives after
+        /// the agent stream. Default is one past the session's max Sequence so it sorts LAST.
+        /// Exception — WhiteGlove Part 1 (<c>phaseLabel == "device_setup"</c>): the web timeline
+        /// splits Pre-Provisioning from User Enrollment strictly by Sequence
+        /// (<c>computeWhiteGloveSplitSequence</c> in eventHelpers.ts), and if Part 2 is already
+        /// running when the Part-1 scan lands, max+1 would push the device_setup report across
+        /// the split and render it as the start of User Enrollment. The Part-1 report therefore
+        /// anchors AT the max Sequence of the Part-1 terminal markers
+        /// (<c>whiteglove_part1_complete</c> / <c>whiteglove_complete</c>) — provably ≤ the web
+        /// split in every split branch, with the timestamp tie-break sorting it right behind the
+        /// marker. Falls back to max+1 when no marker exists (then the web derives no split either).
+        /// </para>
+        /// </summary>
+        internal static EnrollmentEvent BuildVulnerabilityReportEvent(
+            string tenantId,
+            string sessionId,
+            Dictionary<string, object> reportData,
+            string? phaseLabel,
+            IReadOnlyList<EnrollmentEvent> existingEvents,
+            DateTime nowUtc)
+        {
+            var scanSummary = reportData.TryGetValue("scan_summary", out var summaryObj)
+                && summaryObj is Dictionary<string, object> summaryDict
+                ? summaryDict
+                : new Dictionary<string, object>();
+
+            var overallRisk = scanSummary.TryGetValue("overall_risk", out var riskObj)
+                ? riskObj?.ToString()
+                : null;
+
+            var data = new Dictionary<string, object>(StringComparer.Ordinal)
+            {
+                ["scan_summary"] = scanSummary,
+                ["reportAvailable"] = true,
+                ["phase"] = phaseLabel ?? "single",
+            };
+
+            return new EnrollmentEvent
+            {
+                TenantId = tenantId,
+                SessionId = sessionId,
+                EventType = Constants.EventTypes.VulnerabilityReport,
+                Severity = MapVulnerabilityRiskToSeverity(overallRisk),
+                Source = "VulnerabilityCorrelationService",
+                Phase = EnrollmentPhase.Unknown,
+                Message = $"Vulnerability scan complete (risk={overallRisk ?? "unknown"}).",
+                Timestamp = nowUtc,
+                Sequence = ComputeReportEventSequence(phaseLabel, existingEvents),
+                Data = data,
+            };
+        }
+
+        private static long ComputeReportEventSequence(
+            string? phaseLabel, IReadOnlyList<EnrollmentEvent> existingEvents)
+        {
+            if (existingEvents == null || existingEvents.Count == 0)
+                return 1L;
+
+            if (string.Equals(phaseLabel, "device_setup", StringComparison.Ordinal))
+            {
+                var anchor = existingEvents
+                    .Where(e =>
+                        string.Equals(e.EventType, Constants.EventTypes.WhiteGlovePart1Complete, StringComparison.OrdinalIgnoreCase)
+                        || string.Equals(e.EventType, Constants.EventTypes.WhiteGloveComplete, StringComparison.OrdinalIgnoreCase))
+                    .Select(e => (long?)e.Sequence)
+                    .Max();
+                if (anchor.HasValue)
+                    return anchor.Value;
+            }
+
+            return existingEvents.Max(e => e.Sequence) + 1;
+        }
+
        private async Task SafeUpsertCveIndexAsync(
            VulnerabilityCorrelateEnvelope envelope,
            string sessionPrefix,
@@ -110,6 +110,7 @@ export const EVENT_TYPES_CATALOG = {
    'timezone_auto_set',
    'ntp_time_check',
    'power_state_check',
+    'power_state_change',
  ],
  identity_events: [
    'aad_placeholder_user_detected',
@@ -160,7 +160,11 @@ export const RULE_AUTHORING_GUIDE = {
        'Match a phase (eventType=esp_phase_changed, dataField=espPhase, operator=equals, ' +
        'value=<phase>); the evidence carries durationSeconds. Combine with a confidenceFactor ' +
        '"phase_duration > N" for the actual duration check.',
-      app_install_duration: 'Compare app install duration in seconds (operator gt/lt/gte/lte, value=seconds).',
+      app_install_duration:
+        'Compare app install duration in seconds (operator gt/lt/gte/lte, value=seconds). ' +
+        'Attempt-scoped: pairs each completion with the LATEST app_install_started before it ' +
+        '(sequence order), so an IME re-evaluation pass an hour earlier does not inflate the ' +
+        'value — same semantics as the apps dashboard since 2026-08.',
      event_correlation:
        'Join two event types over a shared field: eventType + correlateEventType + joinField, ' +
        'optional timeWindowSeconds, optional eventAFilterField/-Operator/-Value to pre-filter the ' +
@@ -1483,7 +1483,10 @@ export function registerAdminTools(server: McpServer, ga: boolean, strictGa: boo
      description:
        'Get aggregated app-install health for Autopilot enrollments over a time window: the top failing apps ' +
        '(with failure counts, failure rate, and their most common failure codes), the slowest apps by average ' +
-        'install duration, and a fleet "deliveryOptimization" rollup — total bytes downloaded and how much came ' +
+        'install duration (durations measure the FINAL install attempt — the IME processes the app list in ' +
+        'multiple passes, and evaluation passes / time queued behind other apps are not counted; rows written ' +
+        'before 2026-08 carry the old first-observation-to-last-terminal span), and a fleet "deliveryOptimization" ' +
+        'rollup — total bytes downloaded and how much came ' +
        'from peers / Microsoft Connected Cache (MCC) vs. the CDN, plus a peerOffloadPercent (bandwidth saved by ' +
        'not pulling from the internet). Use this to answer "which app breaks or slows down my enrollments?" and ' +
        '"how much install bandwidth is served locally?". ' +
@@ -1528,7 +1531,10 @@ export function registerAdminTools(server: McpServer, ga: boolean, strictGa: boo
        'time breakdown — wall-clock partition into device_prep / esp_apps / identity_hello / user_esp / ' +
        'desktop_handoff spans plus an EXPLICIT unattributed remainder (sums are exact against the session\'s ' +
        'authoritative duration; the WhiteGlove pause is excluded by design), the ESP-blocking app install ' +
-        'intervals with critical-path occupancy, reboot outage spans, and data-quality flags. Omit sessionId ' +
+        'intervals with critical-path occupancy (an app\'s seconds = its ACTIVE install time summed across all ' +
+        'IME passes/attempts — deliberately broader than get_app_install_metrics\' final-attempt duration, ' +
+        'because a failed attempt and an evaluation pass still occupied the critical path), reboot outage ' +
+        'spans, and data-quality flags. Omit sessionId ' +
        'for the fleet rollup: rolling 30-day median/p75/p90 per segment per enrollment class (classes are ' +
        'never mixed) plus the top time-consuming ESP-blocking apps with "up to" what-if savings bounds. ' +
        'breakdown=null means the session has no computable attribution (pre-feature, non-terminal, or ' +
@@ -562,6 +562,7 @@ namespace AutopilotMonitor.Shared
            public const string TimezoneAutoSet           = "timezone_auto_set";
            public const string NtpTimeCheck              = "ntp_time_check";
            public const string PowerStateCheck           = "power_state_check";
+            public const string PowerStateChange          = "power_state_change";
            public const string AgentTrace                = "agent_trace";

            // Crash / process lifecycle
@@ -355,6 +355,16 @@ namespace AutopilotMonitor.Shared.Models
        /// </summary>
        public int OfficeInstallSettleSeconds { get; set; } = 10;

+        /// <summary>
+        /// Enable the live AC/battery power-state watcher. Event-driven (no polling): a WMI
+        /// Win32_PowerManagementEvent (EventCode 10) push triggers a GetSystemPowerStatus
+        /// re-probe; emits power_state_change on AC↔battery transitions and downward battery
+        /// threshold crossings (50/30/15 %). Never armed on devices without a battery.
+        /// Cheap and high-value → on by default, kept as a kill-switch.
+        /// Default: true
+        /// </summary>
+        public bool EnablePowerStateWatcher { get; set; } = true;
+
        // -----------------------------------------------------------------------
        // Stall detection (Ebene 2 — StallProbeCollector)
        // -----------------------------------------------------------------------
@@ -39,8 +39,17 @@ namespace AutopilotMonitor.Shared.Models
        /// <summary>Succeeded / (Succeeded + Failed) * 100 (one decimal) — finished enrollments only,
        /// matching the SLA convention. 0 when nothing has finished yet (clients render "—").</summary>
        public double SuccessRate { get; set; }
-        /// <summary>Average duration in minutes over non-in-progress sessions that carry a duration.</summary>
+        /// <summary>Average duration in minutes over non-in-progress sessions that carry a duration.
+        /// Kept for API compatibility; the cards lead with the median, which a handful of
+        /// multi-hour outliers (overnight ESP, WhiteGlove late user phase) cannot drag around.</summary>
        public int AvgDurationMinutes { get; set; }
+
+        /// <summary>Median duration in minutes over the same population as <see cref="AvgDurationMinutes"/>.</summary>
+        public int MedianDurationMinutes { get; set; }
+
+        /// <summary>90th-percentile duration in minutes over the same population — the tail signal
+        /// the median alone would hide.</summary>
+        public int P90DurationMinutes { get; set; }
    }

    public sealed class FleetDailyPoint
@@ -66,7 +66,14 @@ namespace AutopilotMonitor.Shared.Models
        /// </summary>
        public string TerminalState { get; set; } = string.Empty;

-        /// <summary>Total installation duration in seconds (from start to complete/failed)</summary>
+        /// <summary>
+        /// Duration in seconds of the status-defining (last observed) install attempt:
+        /// <see cref="CompletedAt"/> minus <see cref="LastAttemptStartedAt"/>. Falls back to
+        /// the <see cref="StartedAt"/> anchor (the historical full-span semantics) only when
+        /// no <c>app_install_started</c> was ever observed (legacy agents, terminal-only
+        /// observation). Until 2026-08 this column was the first-observation → last-terminal
+        /// span across ALL install passes — rows from before the change still carry that value.
+        /// </summary>
        public int DurationSeconds { get; set; }

        /// <summary>Total download size in bytes</summary>
@@ -81,12 +88,36 @@ namespace AutopilotMonitor.Shared.Models
        /// <summary>Error message if failed</summary>
        public string FailureMessage { get; set; } = string.Empty;

-        /// <summary>When this app install started</summary>
+        /// <summary>
+        /// When this app was FIRST observed in this session (earliest app-relevant event,
+        /// including download progress). This is the server-side window/bucket filter column
+        /// for every AppInstallSummaries scan and the version-ordering key of the regression
+        /// radar — it is never re-anchored to a later attempt (earliest always wins).
+        /// </summary>
        public DateTime StartedAt { get; set; }

        /// <summary>When this app install completed or failed</summary>
        public DateTime? CompletedAt { get; set; }

+        /// <summary>
+        /// Device-frame timestamp of the most recent observed <c>app_install_started</c> for
+        /// this app in this session — the anchor of <see cref="DurationSeconds"/>. Folds via
+        /// max in-batch and across batches (a replayed older batch can never regress it).
+        /// Null = sentinel: no start observed (row predates the 2026-08 attempt-duration
+        /// change, or the agent never emitted a start) — such rows keep the span fallback.
+        /// </summary>
+        public DateTime? LastAttemptStartedAt { get; set; }
+
+        /// <summary>
+        /// Number of observed install passes (<c>app_install_started</c> events) across the
+        /// session. The IME processes the app list repeatedly (device-ESP evaluation pass,
+        /// user-context pass, retries), so 2+ is normal and explains a
+        /// <see cref="CompletedAt"/> far after <see cref="StartedAt"/>. Additive across
+        /// batches, guarded by <see cref="LastAttemptStartedAt"/> monotonicity so a replayed
+        /// batch is not double-counted. 0 = sentinel (legacy row / never observed).
+        /// </summary>
+        public int InstallPassCount { get; set; }
+
        // Delivery Optimization telemetry
        /// <summary>DO: total file size reported by DO</summary>
        public long DoFileSize { get; set; }
@@ -576,9 +576,17 @@ namespace AutopilotMonitor.Shared.Models
        /// </summary>
        public int SuccessRatePct { get; set; }

-        /// <summary>Average duration of Succeeded sessions in the window, in minutes (rounded).</summary>
+        /// <summary>Average duration of Succeeded sessions in the window, in minutes (rounded).
+        /// Kept for API compatibility; the dashboard card leads with the median, which
+        /// multi-hour outliers cannot drag around.</summary>
        public int AvgDurationMinutes { get; set; }

+        /// <summary>Median duration in minutes over the same Succeeded population.</summary>
+        public int MedianDurationMinutes { get; set; }
+
+        /// <summary>90th-percentile duration in minutes over the same population — the tail signal.</summary>
+        public int P90DurationMinutes { get; set; }
+
        /// <summary>Sessions whose StartedAt is on or after UTC midnight of the current day.</summary>
        public int TotalToday { get; set; }
        public int FailedToday { get; set; }
@@ -0,0 +1,97 @@
+import { describe, it, expect } from "vitest";
+import { EMPTY_FORM, formToEvaluateOn, jsonToForm } from "../types";
+
+/**
+ * The JSON editor serializes the FORM object (eval* checkbox fields), but what users
+ * paste is usually a rule EXPORT (the "Export" button's shape, e.g. received from
+ * another tenant) which carries `evaluateOn` instead. Before the mapper, a pasted
+ * export silently lost evaluateOn — the imported rule quietly reverted to the
+ * enrollment-end default.
+ */
+describe("jsonToForm", () => {
+  const baseExport = {
+    ruleId: "ANALYZE-CUSTOM-101",
+    title: "VPN client install failed",
+    severity: "high",
+    category: "network",
+    conditions: [
+      {
+        signal: "vpn_failed",
+        source: "event_data",
+        eventType: "app_install_failed",
+        dataField: "appName",
+        operator: "contains",
+        value: "VPN",
+        required: true,
+      },
+    ],
+    baseConfidence: 70,
+    confidenceThreshold: 50,
+    tags: ["vpn", "network"],
+  };
+
+  it("maps a rule-shaped export's evaluateOn onto the form flags", () => {
+    const form = jsonToForm({
+      ...baseExport,
+      evaluateOn: ["whiteglove_sealed", "on_event:vpn_error"],
+    });
+
+    expect(form.evalAtEnrollmentEnd).toBe(false);
+    expect(form.evalAtWhitegloveSealed).toBe(true);
+    expect(form.evalOnEventTypes).toBe("vpn_error");
+    expect(form.conditions).toHaveLength(1);
+    expect(form.tags).toEqual(["vpn", "network"]);
+  });
+
+  it("defaults a terminal-only export (no evaluateOn key) to enrollment end", () => {
+    const form = jsonToForm(baseExport);
+
+    expect(form.evalAtEnrollmentEnd).toBe(true);
+    expect(form.evalAtWhitegloveSealed).toBe(false);
+    expect(form.evalOnEventTypes).toBe("");
+  });
+
+  it("passes form-shaped JSON (eval* fields, no evaluateOn) through unchanged", () => {
+    const form = jsonToForm({
+      ...EMPTY_FORM,
+      ruleId: "ANALYZE-CUSTOM-102",
+      title: "Pasted form",
+      evalAtEnrollmentEnd: false,
+      evalAtWhitegloveSealed: true,
+    });
+
+    expect(form.evalAtEnrollmentEnd).toBe(false);
+    expect(form.evalAtWhitegloveSealed).toBe(true);
+  });
+
+  it("prefers an explicit evaluateOn over stale form flags on an edit merge", () => {
+    // Edit-mode paste merges into the current form, so both shapes are present:
+    // the export's evaluateOn must win over the edited rule's stale checkboxes.
+    const form = jsonToForm({
+      ...EMPTY_FORM,
+      ...baseExport,
+      evalAtEnrollmentEnd: true,
+      evaluateOn: ["whiteglove_sealed"],
+    });
+
+    expect(form.evalAtEnrollmentEnd).toBe(false);
+    expect(form.evalAtWhitegloveSealed).toBe(true);
+  });
+
+  it("folds the tenant markSessionAsFailed override into the imported default", () => {
+    // An exported rule that (effectively) marks sessions failed must keep doing so
+    // when re-created in another tenant from its JSON.
+    expect(jsonToForm({ ...baseExport, markSessionAsFailed: true }).markSessionAsFailedDefault).toBe(true);
+    expect(jsonToForm({ ...baseExport, markSessionAsFailedDefault: true }).markSessionAsFailedDefault).toBe(true);
+    expect(jsonToForm({ ...baseExport, markSessionAsFailedDefault: true, markSessionAsFailed: false }).markSessionAsFailedDefault).toBe(false);
+    expect(jsonToForm(baseExport).markSessionAsFailedDefault).toBe(false);
+  });
+
+  it("round-trips evaluateOn through the form and back", () => {
+    const evaluateOn = ["enrollment_end", "whiteglove_sealed", "on_event:vpn_error"];
+
+    expect(formToEvaluateOn(jsonToForm({ ...baseExport, evaluateOn }))).toEqual(evaluateOn);
+    // Terminal-only stays clean of the field (undefined = backend default).
+    expect(formToEvaluateOn(jsonToForm(baseExport))).toBeUndefined();
+  });
+});
@@ -1,7 +1,7 @@
 "use client";

 import { useState } from "react";
-import { AnalyzeRule, RuleForm, getSeverityColor, getCategoryColor, interimTriggerLabels } from "../types";
+import { AnalyzeRule, RuleForm, PastedAnalyzeJson, getSeverityColor, getCategoryColor, interimTriggerLabels, jsonToForm } from "../types";
 import { FormJsonToggle, JsonModeToggleButtons, ReadOnlyJsonView } from "@/components/rules/FormJsonToggle";
 import AnalyzeRuleFormFields from "./AnalyzeRuleFormFields";
 import { stripInternalFields } from "@/lib/rulePageHelpers";
@@ -635,9 +635,11 @@ export default function AnalyzeRuleCard({
            jsonError={jsonError}
            onApplyJson={() => {
              try {
-                const parsed = JSON.parse(jsonText) as RuleForm;
+                const parsed = JSON.parse(jsonText) as PastedAnalyzeJson;
                if (!parsed.title) throw new Error("JSON must include title");
-                setEditForm({ ...editForm, ...parsed });
+                // Merge keeps unmentioned fields; a rule-shaped paste brings an explicit
+                // evaluateOn, which the mapper prefers over the stale eval* form fields.
+                setEditForm(jsonToForm({ ...editForm, ...parsed }));
                onSetJsonModeEdit(false);
                onSetJsonError(null);
              } catch (e) {
@@ -655,9 +657,9 @@ export default function AnalyzeRuleCard({
            <button onClick={() => {
              if (jsonModeEdit) {
                try {
-                  const parsed = JSON.parse(jsonText) as RuleForm;
+                  const parsed = JSON.parse(jsonText) as PastedAnalyzeJson;
                  onSetJsonError(null);
-                  onSaveEdit(rule, { ...editForm, ...parsed });
+                  onSaveEdit(rule, jsonToForm({ ...editForm, ...parsed }));
                } catch (e) {
                  onSetJsonError(e instanceof Error ? e.message : "Invalid JSON");
                }
@@ -16,7 +16,7 @@ import { GlobalAdminBanner, globalAdminSubtitle } from "@/components/GlobalAdmin
 import { TenantScopeSelector } from "@/components/TenantScopeSelector";

 import { isTemplateRule } from "@/lib/analyzeRuleTabs";
-import { AnalyzeRule, RuleForm, EMPTY_FORM, EMPTY_CONDITION, ruleToForm, formToEvaluateOn, validateOnEventTypes } from "./types";
+import { AnalyzeRule, RuleForm, PastedAnalyzeJson, EMPTY_FORM, EMPTY_CONDITION, ruleToForm, jsonToForm, formToEvaluateOn, validateOnEventTypes } from "./types";
 import { BLOCKED_INTERIM_TRIGGER_EVENT_TYPES } from "@/utils/guardrails.generated";

 /** Pre-flight for the evaluation-trigger form fields; returns an error message or null. */
@@ -340,6 +340,8 @@ export default function AnalyzeRulesPage() {
    setCreating(true);
    const payload = {
      evaluateOn: formToEvaluateOn(form),
+      tags: form.tags ?? [],
+      markSessionAsFailedDefault: form.markSessionAsFailedDefault ?? false,
      ruleId: form.ruleId.trim(),
      title: form.title.trim(),
      description: form.description.trim(),
@@ -398,6 +400,8 @@ export default function AnalyzeRulesPage() {
    const payload = {
      ...rule,
      evaluateOn: formToEvaluateOn(form) ?? null,
+      // From the form (not ...rule) so tag changes pasted in JSON mode survive the save.
+      tags: form.tags ?? rule.tags ?? [],
      title: form.title.trim(),
      description: form.description.trim(),
      severity: form.severity,
@@ -797,9 +801,11 @@ export default function AnalyzeRulesPage() {
                      jsonError={jsonError}
                      onApplyJson={() => {
                        try {
-                          const parsed = JSON.parse(jsonText) as RuleForm;
+                          const parsed = JSON.parse(jsonText) as PastedAnalyzeJson;
                          if (!parsed.ruleId && !parsed.title) throw new Error("JSON must include at least ruleId and title");
-                          setNewRule({ ...EMPTY_FORM, ...parsed });
+                          // Handles both shapes: rule-shaped exports (evaluateOn) and the
+                          // serialized form itself (eval* checkbox fields).
+                          setNewRule(jsonToForm(parsed));
                          setJsonModeCreate(false);
                          setJsonError(null);
                        } catch (e) {
@@ -816,9 +822,9 @@ export default function AnalyzeRulesPage() {
                      <button onClick={() => {
                        if (jsonModeCreate) {
                          try {
-                            const parsed = JSON.parse(jsonText) as RuleForm;
+                            const parsed = JSON.parse(jsonText) as PastedAnalyzeJson;
                            setJsonError(null);
-                            handleCreateRule({ ...EMPTY_FORM, ...parsed });
+                            handleCreateRule(jsonToForm(parsed));
                          } catch (e) {
                            setJsonError(e instanceof Error ? e.message : "Invalid JSON");
                          }
@@ -123,6 +123,10 @@ export interface RuleForm {
  evalAtWhitegloveSealed: boolean;
  /** Comma-separated event types for on_event:<type> interim triggers. */
  evalOnEventTypes: string;
+  /** Carried through create/save so exports and JSON pastes don't lose them (no form UI). */
+  tags: string[];
+  /** Effective "fire → mark session failed" carried as the new rule's default on import. */
+  markSessionAsFailedDefault: boolean;
 }

 export const CATEGORIES = ["network", "identity", "apps", "device", "esp", "enrollment"] as const;
@@ -210,6 +214,8 @@ export const EMPTY_FORM: RuleForm = {
  evalAtEnrollmentEnd: true,
  evalAtWhitegloveSealed: false,
  evalOnEventTypes: "",
+  tags: [],
+  markSessionAsFailedDefault: false,
 };

 export function ruleToForm(rule: AnalyzeRule): RuleForm {
@@ -235,9 +241,52 @@ export function ruleToForm(rule: AnalyzeRule): RuleForm {
      .filter(t => t.toLowerCase().startsWith("on_event:"))
      .map(t => t.slice("on_event:".length))
      .join(", "),
+    tags: [...(rule.tags ?? [])],
+    // Fold the tenant override into the effective value: an exported rule that marks
+    // sessions failed must keep doing so when re-created from its JSON.
+    markSessionAsFailedDefault: rule.markSessionAsFailed ?? rule.markSessionAsFailedDefault ?? false,
  };
 }

+/**
+ * What JSON-mode paste can contain: the serialized form, a rule export, or a mix.
+ * Shared fields take the rule's (nullable) typing so an AnalyzeRule assigns directly;
+ * the form-only eval* fields come from RuleForm.
+ */
+export type PastedAnalyzeJson = Partial<AnalyzeRule> & Partial<Omit<RuleForm, keyof AnalyzeRule>>;
+
+/**
+ * Maps pasted JSON into a RuleForm, accepting BOTH shapes: the serialized form (has the
+ * eval* checkbox fields) and a rule-shaped export (has evaluateOn, or neither when the
+ * rule is terminal-only). Without the rule-shaped path, pasting an export silently
+ * dropped evaluateOn — the rule quietly reverted to the enrollment-end default.
+ */
+export function jsonToForm(parsed: PastedAnalyzeJson): RuleForm {
+  // An explicit evaluateOn is authoritative rule-shape; the form fields only decide when
+  // it is absent (a terminal-only export carries neither, which the default handles).
+  const formShaped =
+    parsed.evaluateOn === undefined &&
+    (parsed.evalAtEnrollmentEnd !== undefined ||
+      parsed.evalAtWhitegloveSealed !== undefined ||
+      parsed.evalOnEventTypes !== undefined);
+  if (formShaped) return { ...EMPTY_FORM, ...(parsed as Partial<RuleForm>) };
+
+  return ruleToForm({
+    ...parsed,
+    ruleId: parsed.ruleId ?? "",
+    title: parsed.title ?? "",
+    severity: parsed.severity ?? EMPTY_FORM.severity,
+    category: parsed.category ?? EMPTY_FORM.category,
+    trigger: parsed.trigger ?? EMPTY_FORM.trigger,
+    baseConfidence: parsed.baseConfidence ?? EMPTY_FORM.baseConfidence,
+    confidenceThreshold: parsed.confidenceThreshold ?? EMPTY_FORM.confidenceThreshold,
+    conditions: Array.isArray(parsed.conditions) ? parsed.conditions : [],
+    confidenceFactors: Array.isArray(parsed.confidenceFactors) ? parsed.confidenceFactors : [],
+    remediation: Array.isArray(parsed.remediation) ? parsed.remediation : [],
+    relatedDocs: Array.isArray(parsed.relatedDocs) ? parsed.relatedDocs : [],
+  } as AnalyzeRule);
+}
+
 /**
 * Builds the evaluateOn payload from the structured form fields. Returns undefined when the
 * selection equals the default (enrollment_end only) so unchanged rules stay clean of the field.
@@ -283,7 +283,13 @@ export default function InstallsTab({ scope, timeRange }: InstallsTabProps) {
                <th className="px-4 py-3 cursor-pointer select-none text-right" onClick={() => toggleSort("succeeded")}>Succeeded {sortIndicator("succeeded")}</th>
                <th className="px-4 py-3 cursor-pointer select-none text-right" onClick={() => toggleSort("failed")}>Failed {sortIndicator("failed")}</th>
                <th className="px-4 py-3 cursor-pointer select-none text-right" onClick={() => toggleSort("failureRate")}>Failure Rate {sortIndicator("failureRate")}</th>
-                <th className="px-4 py-3 cursor-pointer select-none text-right" onClick={() => toggleSort("avgDurationSeconds")}>Avg Duration {sortIndicator("avgDurationSeconds")}</th>
+                <th
+                  className="px-4 py-3 cursor-pointer select-none text-right"
+                  onClick={() => toggleSort("avgDurationSeconds")}
+                  title="Average duration of the final install attempt. IME evaluation passes and time queued behind other apps are not counted."
+                >
+                  Avg Install Time {sortIndicator("avgDurationSeconds")}
+                </th>
                <th className="px-4 py-3 cursor-pointer select-none text-right" onClick={() => toggleSort("trend")}>Trend {sortIndicator("trend")}</th>
              </tr>
            </thead>
@@ -142,6 +142,8 @@ interface SessionRow {
  attemptNumber: number;
  startedAt: string;
  durationSeconds: number;
+  /** Observed install passes (2+ = IME evaluation pass + real install); 0 on legacy rows. */
+  installPassCount?: number;
 }

 // ── Affected Sessions: column metadata (for the column picker) ─────────────
@@ -163,7 +165,7 @@ const SESSIONS_COLUMNS: SessionColumn[] = [
  { key: "status", label: "Status", defaultVisible: true },
  { key: "attempts", label: "Attempts", defaultVisible: true, numeric: true },
  { key: "failureCode", label: "Failure Code", defaultVisible: true },
-  { key: "duration", label: "Duration", defaultVisible: true, numeric: true },
+  { key: "duration", label: "Install Time", defaultVisible: true, numeric: true },
 ];

 const SESSIONS_COLUMNS_STORAGE_KEY = "appHealthSessions_visibleColumns";
@@ -544,12 +546,12 @@ function AppDetailContent() {
                  }
                />
                <SummaryCard
-                  label="Avg Duration"
+                  label="Avg Install Time"
                  value={formatDuration(analytics.summary.avgDurationSeconds)}
                  hint={
                    analytics.summary.unmeasured > 0
-                      ? `measured installs only — ${analytics.summary.unmeasured} without observed start`
-                      : "measured installs only"
+                      ? `final attempt, measured installs only — ${analytics.summary.unmeasured} without observed start`
+                      : "final attempt, measured installs only"
                  }
                />
                <SummaryCard label="Trend" value={trendText(analytics.summary.trend, analytics.summary.trendDelta)} />
@@ -588,18 +590,24 @@ function AppDetailContent() {
                    <EmptyState />
                  )}
                </Card>
-                <Card title="Avg Install Duration over time">
+                <Card title="Avg Install Time over time">
                  {analytics.timeSeries.length > 0 ? (
-                    <AppLineChart
-                      data={analytics.timeSeries as unknown as Array<Record<string, unknown>>}
-                      xKey="bucketStart"
-                      series={[
-                        { dataKey: "avgDurationSeconds", label: "Avg duration (s)", color: chartColors.primary },
-                      ]}
-                      yUnit="s"
-                      yDomain={[0, "auto"]}
-                      formatXTick={formatBucketTick}
-                    />
+                    <>
+                      <AppLineChart
+                        data={analytics.timeSeries as unknown as Array<Record<string, unknown>>}
+                        xKey="bucketStart"
+                        series={[
+                          { dataKey: "avgDurationSeconds", label: "Avg install time (s)", color: chartColors.primary },
+                        ]}
+                        yUnit="s"
+                        yDomain={[0, "auto"]}
+                        formatXTick={formatBucketTick}
+                      />
+                      <p className="mt-2 text-xs text-gray-400">
+                        Measures the final install attempt since Aug 2026 — earlier points{" "}
+                        use the older span measurement and read higher.
+                      </p>
+                    </>
                  ) : (
                    <EmptyState />
                  )}
@@ -644,7 +652,7 @@ function AppDetailContent() {
                    </Card>
                  )}
                  {analytics.versionBreakdown.some((v) => v.measuredInstalls > 0) && (
-                    <Card title="Median Install Duration by Version">
+                    <Card title="Median Install Time by Version">
                      <AppBarChart
                        data={analytics.versionBreakdown.filter((v) => v.measuredInstalls > 0) as unknown as Array<Record<string, unknown>>}
                        categoryKey="appVersion"
@@ -952,6 +960,14 @@ function AppDetailContent() {
                                    return (
                                      <td key={col.key} className="px-3 py-2 text-right text-gray-700">
                                        {formatDuration(row.durationSeconds)}
+                                        {(row.installPassCount ?? 0) > 1 && (
+                                          <span
+                                            className="ml-1 text-xs text-gray-400 dark:text-gray-500"
+                                            title={`Processed in ${row.installPassCount} IME passes (evaluation + install) — install time counts only the final attempt`}
+                                          >
+                                            ×{row.installPassCount}
+                                          </span>
+                                        )}
                                      </td>
                                    );
                                  default:
@@ -343,7 +343,7 @@ export function SessionTable({
            className="px-2 py-1.5 rounded-lg text-xs font-medium text-gray-600 bg-gray-100 hover:bg-gray-200 border border-gray-200 transition-colors cursor-pointer focus:outline-none focus:ring-2 focus:ring-green-500"
            title="Sessions per page"
          >
-            {[10, 15, 20, 50, 100].map((n) => (
+            {[5, 10, 15, 20, 50, 100].map((n) => (
              <option key={n} value={n}>{n} per page</option>
            ))}
          </select>
@@ -18,6 +18,10 @@ export interface DashboardStats {
  failedLastNDays: number;
  successRatePct: number;
  avgDurationMinutes: number;
+  /** Median over the same Succeeded population — the card's headline value (outlier-robust). */
+  medianDurationMinutes: number;
+  /** 90th percentile — the tail signal the median alone would hide. */
+  p90DurationMinutes: number;
  totalToday: number;
  failedToday: number;
  computedAt: string;
@@ -27,6 +27,7 @@ import { useDashboardSessions } from "./hooks/useDashboardSessions";
 import { useDashboardStats } from "./hooks/useDashboardStats";
 import { api } from "@/lib/api";
 import { authenticatedFetch } from "@/lib/authenticatedFetch";
+import { formatDuration } from "@/lib/formatting";
 import { hasTenantReadScope } from "@/lib/tenantScope";
 import { DOCS_URL } from "@/utils/config";
 import { TableSkeleton } from "@/components/skeletons/TableSkeleton";
@@ -463,10 +464,22 @@ function HomeContent() {
              description="Last 7 days"
              color="green"
            />
+            {/* Median, not mean — a few overnight/WhiteGlove outliers dominate the average
+                of the right-skewed duration distribution; P90 keeps the tail visible. */}
            <StatsCard
-              title="Avg. Duration"
-              value={dashboardStats ? `${dashboardStats.avgDurationMinutes} min` : "..."}
-              description="Last 7 days"
+              title="Median Duration"
+              value={
+                dashboardStats
+                  ? dashboardStats.medianDurationMinutes > 0
+                    ? `${dashboardStats.medianDurationMinutes} min`
+                    : "—"
+                  : "..."
+              }
+              description={
+                dashboardStats && dashboardStats.p90DurationMinutes > 0
+                  ? `P90 ${formatDuration(dashboardStats.p90DurationMinutes * 60)} · last 7 days`
+                  : "Last 7 days"
+              }
              color="purple"
            />
            <StatsCard
@@ -20,6 +20,10 @@ export interface FleetHealthStats {
  /** Succeeded / (succeeded + failed) — finished enrollments only. 0 when nothing finished yet. */
  successRate: number;
  avgDurationMinutes: number;
+  /** Median over the same population as avg — the card's headline value (outlier-robust). */
+  medianDurationMinutes: number;
+  /** 90th percentile — the tail signal the median alone would hide. */
+  p90DurationMinutes: number;
 }
 export interface FleetDailyPoint {
  date: string;
@@ -23,6 +23,7 @@ import { TenantScopeSelector } from "@/components/TenantScopeSelector";
 import { SegmentedControl, TIME_RANGE_OPTIONS } from "@/components/SegmentedControl";
 import { CardSkeleton } from "@/components/skeletons/PageSkeleton";
 import { TableSkeleton } from "@/components/skeletons/TableSkeleton";
+import { formatDuration } from "@/lib/formatting";

 interface AppMetric {
  appName: string;
@@ -164,8 +165,7 @@ export default function FleetHealthPage() {
  }, [isConnected, effectiveTenantId, joinGroup, leaveGroup]);

  // Server payload, with presentation-friendly defaults so the JSX renders
-  // without null guards once loading clears. `avgDuration` keeps the card's
-  // original field name (server sends avgDurationMinutes).
+  // without null guards once loading clears.
  const s = data?.stats;
  const stats = {
    total: s?.total ?? 0,
@@ -174,7 +174,8 @@ export default function FleetHealthPage() {
    inProgress: s?.inProgress ?? 0,
    incomplete: s?.incomplete ?? 0,
    successRate: s?.successRate ?? 0,
-    avgDuration: s?.avgDurationMinutes ?? 0,
+    medianDuration: s?.medianDurationMinutes ?? 0,
+    p90Duration: s?.p90DurationMinutes ?? 0,
  };
  // Success rate is an outcome quota over finished enrollments (succeeded + failed);
  // with none finished there is no rate to show — the card renders "—" instead of 0%.
@@ -301,10 +302,17 @@ export default function FleetHealthPage() {
                  : "red"
              }
            />
+            {/* Median, not mean: enrollment durations are heavily right-skewed, so a few
+                overnight/WhiteGlove outliers made the old average card read like hours.
+                The P90 subtitle keeps the tail visible — that skew is the diagnostic signal. */}
            <FleetStatCard
-              title="Avg. Enrollment Time"
-              value={`${stats.avgDuration} min`}
-              subtitle="Completed enrollments"
+              title="Median Enrollment Time"
+              value={stats.medianDuration > 0 ? `${stats.medianDuration} min` : "—"}
+              subtitle={
+                stats.p90Duration > 0
+                  ? `P90 ${formatDuration(stats.p90Duration * 60)} · completed enrollments`
+                  : "Completed enrollments"
+              }
              color="blue"
            />
            <FleetStatCard
@@ -560,7 +568,7 @@ export default function FleetHealthPage() {
                Slowest Apps
                <span
                  className="ml-2 text-xs font-normal text-gray-400"
-                  title="Averages are computed over installs with an observed duration only. Skipped (not-applicable) installs and installs whose start was never observed are excluded."
+                  title="Averages measure the final install attempt only — IME evaluation passes and time queued behind other apps are not counted. Computed over installs with an observed duration; skipped (not-applicable) installs and installs whose start was never observed are excluded."
                >
                  measured installs
                </span>
@@ -4,6 +4,7 @@ import {
  NewRuleForm,
  buildScopeFields,
  firesExactlyOnce,
+  gatherRuleToForm,
  supportsEmitMode,
  supportsPhaseScope,
  validateScopeSelection,
@@ -134,3 +135,98 @@ describe("withDerivedScopeMode", () => {
    expect(withDerivedScopeMode(parsed).activePhases).toEqual([]);
  });
 });
+
+/**
+ * The JSON editor serializes the FORM object, but what users paste is usually a rule
+ * EXPORT (the "Export" button's shape) — e.g. a rule received from another tenant.
+ * Exports keep collector options in a nested `parameters` object; before the mapper,
+ * that key was silently discarded and the imported rule lost every parameter.
+ */
+describe("gatherRuleToForm", () => {
+  it("unflattens the parameters object of a rule-shaped export", () => {
+    const form = gatherRuleToForm({
+      ruleId: "CONTOSO-WIFI-001",
+      title: "WiFi driver version",
+      collectorType: "registry",
+      target: "HKLM\\SOFTWARE\\Contoso",
+      parameters: { valueName: "DriverVersion", listSubkeys: "true" },
+      trigger: "startup",
+      intervalSeconds: null,
+      triggerPhase: null,
+      triggerEventType: null,
+      outputEventType: "contoso_wifi_driver",
+      outputSeverity: "info",
+      tags: ["contoso", "network"],
+    });
+
+    expect(form.valueName).toBe("DriverVersion");
+    expect(form.listSubkeys).toBe(true);
+    expect(form.tags).toEqual(["contoso", "network"]);
+    expect(form.intervalSeconds).toBe(60);
+    // A rule without emitMode behaves "always" — the import must not upgrade it to
+    // the empty-form on_change default.
+    expect(form.emitMode).toBe("always");
+  });
+
+  it("prefers the parameters object over stale flat fields on an edit merge", () => {
+    const staleEditForm = { ...EMPTY_FORM, logPattern: "old-pattern", trackPosition: false };
+    const form = gatherRuleToForm({
+      ...staleEditForm,
+      title: "IME log watcher",
+      collectorType: "logparser",
+      target: "%ProgramData%\\Logs\\App*.log",
+      parameters: { pattern: "new-pattern", maxLines: "50" },
+    });
+
+    expect(form.logPattern).toBe("new-pattern");
+    expect(form.maxLines).toBe("50");
+    // parameters is authoritative: keys it does not carry fall back to collector defaults,
+    // not to the stale flat fields of the previously edited rule.
+    expect(form.trackPosition).toBe(true);
+  });
+
+  it("passes form-shaped JSON (no parameters key) through unchanged", () => {
+    const form = gatherRuleToForm({
+      ...EMPTY_FORM,
+      ruleId: "GATHER-CUSTOM-101",
+      title: "Pasted form",
+      valueName: "State",
+      emitMode: "on_change",
+      scopeMode: "from",
+      activeFromPhase: "AccountSetup",
+    });
+
+    expect(form.valueName).toBe("State");
+    expect(form.emitMode).toBe("on_change");
+    // scopeMode is UI-only and re-derived from the data, exactly like withDerivedScopeMode.
+    expect(form.scopeMode).toBe("from");
+  });
+
+  it("round-trips a rule through form and back without losing scope or params", () => {
+    const exported = {
+      ruleId: "GATHER-CUSTOM-042",
+      title: "Battery status",
+      collectorType: "wmi",
+      target: "SELECT BatteryStatus FROM Win32_Battery",
+      parameters: {},
+      trigger: "interval",
+      intervalSeconds: 300,
+      activePhases: ["DeviceSetup", "AppsDevice"],
+      emitMode: "on_change",
+      outputEventType: "battery_status",
+      outputSeverity: "info",
+      tags: ["power"],
+    };
+
+    const form = gatherRuleToForm(exported);
+    expect(form.scopeMode).toBe("during");
+    expect(form.activePhases).toEqual(["DeviceSetup", "AppsDevice"]);
+    expect(form.intervalSeconds).toBe(300);
+    expect(form.emitMode).toBe("on_change");
+    expect(buildScopeFields(form)).toEqual({
+      activePhases: ["DeviceSetup", "AppsDevice"],
+      activeFromPhase: null,
+      emitMode: "on_change",
+    });
+  });
+});
@@ -1,7 +1,7 @@
 "use client";

 import { useMemo, useState } from "react";
-import { GatherRule, NewRuleForm, CATEGORY_COLORS, COLLECTOR_TYPE_LABELS, formatTrigger, formatGatherPhase, withDerivedScopeMode } from "../types";
+import { GatherRule, NewRuleForm, PastedGatherJson, CATEGORY_COLORS, COLLECTOR_TYPE_LABELS, formatTrigger, formatGatherPhase, gatherRuleToForm } from "../types";
 import { GatherRuleFormFields } from "./GatherRuleFormFields";
 import { FormJsonToggle, JsonModeToggleButtons, ReadOnlyJsonView } from "@/components/rules/FormJsonToggle";
 import { validateGatherRuleTarget } from "@/utils/guardValidation";
@@ -484,8 +484,8 @@ export function GatherRuleCard({
              onClick={() => {
                if (jsonModeEdit) {
                  try {
-                    const parsed = JSON.parse(jsonText) as NewRuleForm;
-                    onSaveEdit(rule, withDerivedScopeMode({ ...editForm, ...parsed }));
+                    const parsed = JSON.parse(jsonText) as PastedGatherJson;
+                    onSaveEdit(rule, gatherRuleToForm({ ...editForm, ...parsed }));
                  } catch {
                    // jsonError is handled by parent
                  }
@@ -152,6 +152,8 @@ export const KNOWN_EVENT_TYPES: EventTypeEntry[] = [
    description: "Certificate validation result." },
  { value: "network_state_change", label: "network_state_change", category: "diagnostics",
    description: "Network state changed (online/offline/interface)." },
+  { value: "power_state_change", label: "power_state_change", category: "diagnostics",
+    description: "Live AC/battery change during enrollment (WMI push, no polling): transition=ac_to_battery (Warning) / battery_to_ac (Info) / threshold_crossed with thresholdPercent 50/30/15 (each level latched once per session). Payload carries onAcPower, batteryPercent, isCharging, batteryLifeMinutes. Never emitted on devices without a battery." },
  { value: "network_bandwidth_estimate", label: "network_bandwidth_estimate", category: "diagnostics",
    description: "Session-level internet-bandwidth estimate derived passively from the Delivery Optimization byte counters (no synthetic traffic). At most twice per session: an interim snapshot after DeviceSetup (snapshotTrigger=device_setup_end — survives account-phase starvation) and the authoritative final at enrollment end (collector_stop). p90/max Mbit/s for internet-path (HTTP + internet peers) and LAN sources (peers/Connected Cache) separately, plus bucket (<10 / 10-50 / 50-100 / 100-250 / 250+) and confidence." },
  { value: "vulnerability_report", label: "vulnerability_report", category: "diagnostics",
@@ -14,7 +14,7 @@ import { FormJsonToggle, JsonModeToggleButtons } from "@/components/rules/FormJs
 import { useAuthenticatedFetch, useNotificationMessages, useGlobalAdminScope } from "@/hooks";
 import { GlobalAdminBanner, globalAdminSubtitle } from "@/components/GlobalAdminBanner";
 import { TenantScopeSelector } from "@/components/TenantScopeSelector";
-import { GatherRule, NewRuleForm, EMPTY_FORM, PHASE_TRIGGERS, buildScopeFields, targetBlocked, validateScopeSelection, withDerivedScopeMode } from "./types";
+import { GatherRule, NewRuleForm, PastedGatherJson, EMPTY_FORM, PHASE_TRIGGERS, buildScopeFields, gatherRuleToForm, targetBlocked, validateScopeSelection } from "./types";
 import { GatherRuleFormFields } from "./components/GatherRuleFormFields";
 import { GatherRuleCard } from "./components/GatherRuleCard";
 import { DOCS_URL } from "@/utils/config";
@@ -238,6 +238,7 @@ export default function GatherRulesPage() {
      ...buildScopeFields(form),
      outputEventType: form.outputEventType,
      outputSeverity: form.outputSeverity,
+      tags: form.tags ?? [],
      enabled: !blocked,
    };

@@ -267,41 +268,7 @@ export default function GatherRulesPage() {
    // Ensure the card stays expanded when entering edit mode
    setExpandedRuleId(rule.ruleId);
    setEditingRuleId(rule.ruleId);
-    setEditForm({
-      ruleId: rule.ruleId,
-      title: rule.title,
-      description: rule.description,
-      category: rule.category,
-      collectorType: rule.collectorType,
-      target: rule.target,
-      valueName: rule.parameters?.valueName || "",
-      listSubkeys: rule.parameters?.listSubkeys === "true",
-      eventId: rule.parameters?.eventId || "",
-      messageFilter: rule.parameters?.messageFilter || "",
-      maxEntries: rule.parameters?.maxEntries || "",
-      source: rule.parameters?.source || "",
-      readContent: rule.parameters?.readContent === "true",
-      logPattern: rule.parameters?.pattern || "",
-      logFormat: rule.parameters?.format || "cmtrace",
-      trackPosition: rule.parameters?.trackPosition !== "false",
-      maxLines: rule.parameters?.maxLines || "",
-      jsonPath: rule.parameters?.jsonpath || "",
-      xpath: rule.parameters?.xpath || "",
-      xmlNamespaces: rule.parameters?.namespaces || "",
-      maxResults: rule.parameters?.maxResults || "",
-      trigger: rule.trigger,
-      intervalSeconds: rule.intervalSeconds || 60,
-      triggerPhase: rule.triggerPhase || "",
-      triggerEventType: rule.triggerEventType || "",
-      scopeMode: rule.activePhases?.length ? "during" : rule.activeFromPhase ? "from" : "always",
-      activePhases: rule.activePhases || [],
-      activeFromPhase: rule.activeFromPhase || "",
-      // Existing rules without the field keep today's behavior ("always") — the on_change
-      // default applies to NEW rules only.
-      emitMode: rule.emitMode === "on_change" ? "on_change" : "always",
-      outputEventType: rule.outputEventType,
-      outputSeverity: rule.outputSeverity,
-    });
+    setEditForm(gatherRuleToForm(rule));
  };

  const handleSaveEdit = async (rule: GatherRule, overrideForm?: NewRuleForm) => {
@@ -338,8 +305,9 @@ export default function GatherRulesPage() {
      version: bumpVersion(rule.version),
      enabled: rule.enabled && !forcedOff,
      createdAt: rule.createdAt,
-      // Same wipe class as the toggle bug: the full-replace PUT must carry tags or they vanish.
-      tags: rule.tags ?? [],
+      // Same wipe class as the toggle bug: the full-replace PUT must carry tags or they
+      // vanish. The form carries them (populated by gatherRuleToForm, editable via JSON).
+      tags: form.tags ?? rule.tags ?? [],
      isBuiltIn: rule.isBuiltIn ?? false,
      isCommunity: rule.isCommunity ?? false,
    };
@@ -550,11 +518,11 @@ export default function GatherRulesPage() {
                      jsonError={jsonError}
                      onApplyJson={() => {
                        try {
-                          const parsed = JSON.parse(jsonText) as NewRuleForm;
+                          const parsed = JSON.parse(jsonText) as PastedGatherJson;
                          if (!parsed.ruleId && !parsed.title) throw new Error("JSON must include at least ruleId and title");
-                          // Rule-shaped JSON carries activePhases/activeFromPhase but no scopeMode
-                          // — derive it so the scope fields survive into the create payload.
-                          setNewRule(withDerivedScopeMode({ ...EMPTY_FORM, ...parsed }));
+                          // Handles both shapes: rule-shaped exports (nested parameters,
+                          // no scopeMode) and the serialized form itself.
+                          setNewRule(gatherRuleToForm(parsed));
                          setJsonModeCreate(false);
                          setJsonError(null);
                        } catch (e) {
@@ -585,9 +553,9 @@ export default function GatherRulesPage() {
                        onClick={() => {
                          if (jsonModeCreate) {
                            try {
-                              const parsed = JSON.parse(jsonText) as NewRuleForm;
+                              const parsed = JSON.parse(jsonText) as PastedGatherJson;
                              setJsonError(null);
-                              handleCreateRule(withDerivedScopeMode({ ...EMPTY_FORM, ...parsed }));
+                              handleCreateRule(gatherRuleToForm(parsed));
                            } catch (e) {
                              setJsonError(e instanceof Error ? e.message : "Invalid JSON");
                            }
@@ -666,9 +634,11 @@ export default function GatherRulesPage() {
                      onJsonTextChange={(text) => { setJsonText(text); setJsonError(null); }}
                      onApplyJson={() => {
                        try {
-                          const parsed = JSON.parse(jsonText) as NewRuleForm;
+                          const parsed = JSON.parse(jsonText) as PastedGatherJson;
                          if (!parsed.title) throw new Error("JSON must include title");
-                          setEditForm(withDerivedScopeMode({ ...editForm, ...parsed }));
+                          // Merge keeps unmentioned fields; a rule-shaped paste brings a
+                          // parameters object, which the mapper prefers over stale flat fields.
+                          setEditForm(gatherRuleToForm({ ...editForm, ...parsed }));
                          setJsonModeEdit(false);
                          setJsonError(null);
                        } catch (e) {
@@ -59,6 +59,7 @@ export interface NewRuleForm {
  emitMode: string;
  outputEventType: string;
  outputSeverity: string;
+  tags: string[];
 }

 export const CATEGORIES = ["network", "identity", "apps", "device", "esp", "enrollment"] as const;
@@ -169,6 +170,7 @@ export const EMPTY_FORM: NewRuleForm = {
  emitMode: "on_change",
  outputEventType: "",
  outputSeverity: "info",
+  tags: [],
 };

 export function formatTrigger(trigger: string) {
@@ -265,3 +267,59 @@ export function withDerivedScopeMode(form: NewRuleForm): NewRuleForm {
  const emitMode = form.emitMode === "on_change" ? "on_change" : "always";
  return { ...form, activePhases, activeFromPhase, scopeMode, emitMode };
 }
+
+/**
+ * What JSON-mode paste can contain: the serialized form, a rule export, or a mix.
+ * Shared fields take the rule's (nullable) typing so a GatherRule assigns directly;
+ * the form-only flat fields come from NewRuleForm.
+ */
+export type PastedGatherJson = Partial<GatherRule> & Partial<Omit<NewRuleForm, keyof GatherRule>>;
+
+/**
+ * Maps rule-shaped OR form-shaped JSON into a NewRuleForm. Rule exports carry a nested
+ * `parameters` object (collector options) while the form stores them as flat fields —
+ * without this unflattening, pasting an export into the JSON editor silently dropped
+ * every collector parameter. When `parameters` is present it is authoritative and the
+ * flat fields are ignored (they can only be stale merge leftovers); form-shaped JSON
+ * (no `parameters` key — the shape the JSON toggle serializes) keeps its flat fields.
+ * Also the single mapper behind startEditing, so edit and paste stay equivalent.
+ */
+export function gatherRuleToForm(input: PastedGatherJson): NewRuleForm {
+  const p = input.parameters && typeof input.parameters === "object" ? input.parameters : null;
+  return withDerivedScopeMode({
+    ...EMPTY_FORM,
+    ruleId: input.ruleId ?? "",
+    title: input.title ?? "",
+    description: input.description ?? "",
+    category: input.category ?? EMPTY_FORM.category,
+    collectorType: input.collectorType ?? EMPTY_FORM.collectorType,
+    target: input.target ?? "",
+    valueName: p ? p.valueName || "" : input.valueName ?? "",
+    listSubkeys: p ? p.listSubkeys === "true" : input.listSubkeys ?? false,
+    eventId: p ? p.eventId || "" : input.eventId ?? "",
+    messageFilter: p ? p.messageFilter || "" : input.messageFilter ?? "",
+    maxEntries: p ? p.maxEntries || "" : input.maxEntries ?? "",
+    source: p ? p.source || "" : input.source ?? "",
+    readContent: p ? p.readContent === "true" : input.readContent ?? false,
+    logPattern: p ? p.pattern || "" : input.logPattern ?? "",
+    logFormat: p ? p.format || "cmtrace" : input.logFormat ?? "cmtrace",
+    trackPosition: p ? p.trackPosition !== "false" : input.trackPosition ?? true,
+    maxLines: p ? p.maxLines || "" : input.maxLines ?? "",
+    jsonPath: p ? p.jsonpath || "" : input.jsonPath ?? "",
+    xpath: p ? p.xpath || "" : input.xpath ?? "",
+    xmlNamespaces: p ? p.namespaces || "" : input.xmlNamespaces ?? "",
+    maxResults: p ? p.maxResults || "" : input.maxResults ?? "",
+    trigger: input.trigger ?? EMPTY_FORM.trigger,
+    intervalSeconds: input.intervalSeconds || 60,
+    triggerPhase: input.triggerPhase ?? "",
+    triggerEventType: input.triggerEventType ?? "",
+    activePhases: input.activePhases ?? [],
+    activeFromPhase: input.activeFromPhase ?? "",
+    // A rule without the field behaves "always"; only an explicit on_change survives —
+    // the on_change default is for rules started from the empty form, not for imports.
+    emitMode: input.emitMode ?? "always",
+    outputEventType: input.outputEventType ?? "",
+    outputSeverity: input.outputSeverity ?? EMPTY_FORM.outputSeverity,
+    tags: Array.isArray(input.tags) ? input.tags.filter((t): t is string => typeof t === "string") : [],
+  });
+}
@@ -189,15 +189,20 @@ export function prepareReportModel(input: AppReportInput): AppReportModel {
      tone: failureRateTone(s.failureRate),
    },
    {
-      label: "Avg duration",
+      label: "Avg install time",
      value: formatDuration(s.avgDurationSeconds),
      tone: "default",
      hint:
        s.unmeasured > 0
-          ? `measured installs only — ${s.unmeasured} without observed start`
-          : "measured installs only",
+          ? `final attempt, measured installs only — ${s.unmeasured} without observed start`
+          : "final attempt, measured installs only",
+    },
+    {
+      label: "P95 install time",
+      value: formatDuration(s.p95DurationSeconds),
+      tone: "default",
+      hint: "final attempt, measured installs only",
    },
-    { label: "P95 duration", value: formatDuration(s.p95DurationSeconds), tone: "default" },
    {
      label: "Trend",
      value: trendText(s.trend, s.trendDelta),
@@ -100,7 +100,7 @@ export function buildAppReportDoc(model: AppReportModel, generatedAt: Date): jsP
  drawStackedBarChart(doc, { x: pdfPage.margin, y: ctx.y, w: contentW, h: BAR_CHART_H }, model.timeSeries);
  ctx.y += BAR_CHART_H + 2;

-  sectionTitle(ctx, "Avg Install Duration over time", LINE_CHART_H + 2);
+  sectionTitle(ctx, "Avg Install Time over time", LINE_CHART_H + 2);
  drawLineChart(doc, { x: pdfPage.margin, y: ctx.y, w: contentW, h: LINE_CHART_H }, model.timeSeries);
  ctx.y += LINE_CHART_H + 2;

@@ -146,8 +146,8 @@ export function buildAppReportDoc(model: AppReportModel, generatedAt: Date): jsP
        { header: "Installs", width: 22, align: "right" },
        { header: "Failed", width: 22, align: "right" },
        { header: "Failure rate", width: 26, align: "right" },
-        { header: "Median dur.", width: 25, align: "right" },
-        { header: "P95 dur.", width: 25, align: "right" },
+        { header: "Median install", width: 25, align: "right" },
+        { header: "P95 install", width: 25, align: "right" },
      ],
      rows: model.versions.rows,
      moreCount: model.versions.moreCount,
@@ -134,7 +134,7 @@ export function drawStackedBarChart(doc: jsPDF, region: ChartRegion, points: Rep
  });
 }

-/** "Avg Install Duration over time": blue polyline, dot markers when sparse. */
+/** "Avg Install Time over time" (final attempt): blue polyline, dot markers when sparse. */
 export function drawLineChart(doc: jsPDF, region: ChartRegion, points: ReportTimeSeriesPoint[]) {
  if (points.length === 0) {
    drawEmptyPlaceholder(doc, region);
@@ -142,7 +142,7 @@ export function drawLineChart(doc: jsPDF, region: ChartRegion, points: ReportTim
  }
  const plot = plotArea(region);
  const { max, ticks } = niceTicks(Math.max(...points.map((p) => p.avgDurationSeconds)));
-  drawLegend(doc, region, [{ label: "Avg duration", color: pdfColors.primary }]);
+  drawLegend(doc, region, [{ label: "Avg install time", color: pdfColors.primary }]);
  drawAxes(doc, plot, ticks, max, "s", points);
  const yScale = linearScale(max, plot.h);
  const slotW = plot.w / points.length;
@@ -596,6 +596,7 @@ export const SHARED_MANIFEST = {
    "performance_collector_stopped",
    "performance_snapshot",
    "phase_transition",
+    "power_state_change",
    "power_state_check",
    "previous_crash_detected",
    "prior_run_died_with_state",
@@ -592,6 +592,7 @@
    "performance_collector_stopped",
    "performance_snapshot",
    "phase_transition",
+    "power_state_change",
    "power_state_check",
    "previous_crash_detected",
    "prior_run_died_with_state",
Author	SHA1	Message	Date
Oliver Kieselbach	ba2a390a83	fix(agent): battery-instance fallback for the dead Win32_PowerManagementEvent provider On Windows 11 24H2/25H2 (observed on builds 26200 and 26220, session 161b838c) the MS_Power_Management_Event_Provider is still registered in the WMI repository but activating the extrinsic push query fails with WBEM_E_NOT_FOUND - the legacy provider no longer loads on exactly the OS builds new devices enroll with, so the power watcher degraded fleet-wide. Arm chain: try the push event first (still alive on older builds), then fall back to the intrinsic __InstanceModificationEvent WITHIN 30 on Win32_Battery. The WITHIN sampling runs inside WinMgmt, not in the agent; the handler path is unchanged (payload ignored, re-probe + diff), worst-case detection latency ~35s incl. debounce. collector_degraded now fires only when BOTH attempts fail; the arm log line names the active mode. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 15:49:03 +02:00
Oliver Kieselbach	dbd7d2ac6f	Page-Size-Option „5"	2026-08-21 15:26:03 +02:00
Oliver Kieselbach	8f24876682	feat(agent): live power-state watcher + battery analyze rules DEV-009/010 Event-driven AC/battery observation during enrollment (no polling): a WMI Win32_PowerManagementEvent (EventCode 10) push subscription re-probes GetSystemPowerStatus and diffs snapshots through a pure tracker into power_state_change events - transition ac_to_battery (Warning, immediate) / battery_to_ac (Info) / threshold_crossed at 50/30/15% (per-level lifetime latch, lowest-crossed-only on jumps, arm-time baseline covers sessions starting low, 5s trailing-edge debounce, emission cap 20). Never armed on devices without a battery; arm failure surfaces as collector_degraded. Kill-switch Collectors.EnablePowerStateWatcher (ConfigVersion 38). power_state_change is classified non-activity on both sides (SignalActivityClassifier + IsPeriodicOrStallEvent) so battery drain can neither keep idle collectors alive nor heal a Stalled session. New analyze rules, both with on_event:power_state_change interim triggers and deliberately single-required-condition (event_data conditions scan events independently - no same-instance join): - ANALYZE-DEV-009 (high): thresholdPercent equals 15 - ANALYZE-DEV-010 (warning): transition equals ac_to_battery Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 15:24:41 +02:00
Oliver Kieselbach	2d5ee887d7	fix(web): make rule JSON paste-import lossless in both rule editors The JSON editors serialize the FORM object, but what users paste is usually a rule EXPORT (e.g. received from another tenant). The create/edit whitelists rebuilt collector parameters and evaluateOn from form fields the export does not carry, so a pasted gather rule silently lost every collector parameter and a pasted analyze rule silently reverted to the enrollment-end default. Both rules pages get a single shape-tolerant mapper in types.ts: - gatherRuleToForm unflattens the nested parameters object (authoritative when present, so edit-merge leftovers cannot leak), maps nullable rule fields to form defaults, imports a missing emitMode as 'always' (the rule's actual behavior) instead of the empty-form on_change default, and now also backs startEditing so edit and paste share one mapping. - analyze jsonToForm maps evaluateOn onto the eval* checkboxes (an explicit evaluateOn wins over stale form flags in edit-mode merges); terminal-only exports fall back to the enrollment-end default. - tags and the folded effective markSessionAsFailed now survive the import: both forms carry tags into the create/save payloads, analyze creates carry markSessionAsFailedDefault. notify/notifyChannelIds stay excluded — channel ids are tenant-specific. 9 new vitest cases pin both shapes, the merge precedence, and the round-trips; full web suite 824/824, tsc and eslint clean. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 14:29:08 +02:00
Oliver Kieselbach	81c14bb3ed	fix(rules): close the rule-ID namespace gaps around the shared global keyspace Custom rules are tenant-partitioned and functionally collision-free, but three surfaces still keyed on the bare non-unique ruleId string: - RuleStats global aggregate (global_{ruleId}) summed same-ID custom rules of unrelated tenants (title/severity last-writer-wins). The global row is now catalog-only: analyze gates on IsBuiltIn/IsCommunity, gather gates on the reserved-namespace pattern (agent events carry no flag; custom rules can never occupy the reserved pattern). - The 'never ship a built-in in the CUSTOM namespace' commitment from RuleIdPolicy was documented but unenforced: combine.js now fails on duplicate or non-reserved built-in IDs, BuiltInRuleCatalogPolicyTests pins the same invariants on the embedded catalog, and the GitHub reseed rejects non-reserved IDs before writing to the global partition. - DeleteRuleStatesForRuleIdAcrossTenantsAsync (cross-partition delete by bare RowKey) now refuses IDs outside the reserved namespace with failed=-1 so callers abort the follow-up global catalog delete. Verified: prod global partitions (45 analyze + 11 gather) are fully inside the reserved namespace, so the guards touch no existing data. New OKF doc docs/rules/rule-id-namespace.md captures the identity/collision model. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 14:13:46 +02:00
Oliver Kieselbach	3a0bd74b12	fix(backend): sequence the synthetic vulnerability_report event instead of defaulting to 0 The async queue correlation stored the event with Sequence 0, sorting it to the top of the timeline (and tripping the time-jump badge) even though it arrives last. Follow the BuildSessionTimeoutEvent/BuildAgentEmergencyBreakEvent pattern: max+1 so it sorts last; WhiteGlove Part 1 anchors at the Part-1 terminal markers so a late device_setup report can never cross the web timeline's sequence-based Part-1/Part-2 split. Also upsert the EventType index the queue path never wrote, making the event visible to cross-session search. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 13:57:16 +02:00
Oliver Kieselbach	50e7590060	feat: app install durations measure the status-defining attempt The IME processes the ESP app list in multiple passes (device-ESP evaluation ending Skipped, real install up to an hour later), and AppInstallSummary folded first observation -> last terminal across them: a 23-second app late in the queue reported 4002 s (session 44862cd3, "Set TimeZone"). Backend ingest: new max-folded LastAttemptStartedAt anchors DurationSeconds (CompletedAt - last attempt start; legacy rows without the anchor keep the span fallback), replay-guarded additive InstallPassCount, attempt-scoped DownloadDurationSeconds pairing, and a weaker-terminal guard (completed with state Skipped/Postponed never overrides Installed/Error, in-batch and in the cross-batch reconcile). StartedAt stays the earliest-wins window/version- ordering key. AppsDashboardProjection carries the new columns. AppVersionRegressionRadar: cutover gate — only attempt-anchored rows enter the duration population on BOTH comparison sides, so mixed-semantics medians can neither mask real regressions nor falsely re-arm active episodes. Time attribution: per-pass segment pairing replaces the first-start -> last-terminal hull. An app's seconds = sum of its ACTIVE segments (failed attempts and evaluation passes count; inter-pass idle gaps don't), occupancy merges the segments, hull endpoints remain for display and what-if bounds. Agent: a terminal->active transition re-arms BOTH timing endpoints, so event payload durationSeconds also describes the attempt. Web/PDF/MCP: labels and tooltips say "install time (final attempt)", the apps sessions table gets a xN multi-pass chip, the time-series chart carries a cutover footnote, MCP tool descriptions document the semantics split between get_app_install_metrics and get_time_attribution. No backfill: pre-cutover rows keep span values (documented in the public changelog). OKF doc: docs/backend/app-install-duration-attempt.md. Suites: Functions 4383, Agent 2407, MCP 564, Web 814 - all green, build 0/0. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 13:40:47 +02:00
Oliver Kieselbach	61e53a2e9b	feat: lead duration cards with median + P90 instead of outlier-skewed average Enrollment durations are heavily right-skewed; a handful of overnight/WhiteGlove outliers made the Fleet Health and Dashboard average cards read like hours (541 min) and answer no real question. Both cards now lead with the median (robust 'typical enrollment' answer) and keep the tail visible via a P90 subtext. AvgDurationMinutes stays in both DTOs for API compatibility. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 12:49:42 +02:00
Oliver Kieselbach	7e7b6f8086	fix(backend): declare LastIngestAt in the SessionsIndex manifest `bbc7a1d8` stamped LastIngestAt into IncrementSessionEventCountAsync's merge entity intending it as Sessions-only ("deliberately not mirrored"), but that same entity flows through SyncSessionIndexAsync into the index merge — the field was already landing in SessionsIndex on every ingest batch, just undeclared. The fail-soft drift guard has been warning ~1,200x/h in prod since the 08-20 deploy, and a StartedAt-shift full rebuild would silently drop the column, making index-served session reads lose lastIngestAt that Sessions-served reads carry. Declare it properly instead of suppressing: ConditionallyProjected in SessionIndexFieldManifest, projected in BuildSessionIndexEntity (read side MapToSessionSummary already handled it), sample value pinned in the bidirectional manifest tests. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-08-21 01:54:34 +02:00