Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
fix(patrol): resolve disk alerts through canonical resource owners
rcourtman19d016d7dfab
diff --git a/docs/release-control/v6/internal/subsystems/ai-runtime.md b/docs/release-control/v6/internal/subsystems/ai-runtime.mdindex 0150ca214e..16be3542e0 100644--- a/docs/release-control/v6/internal/subsystems/ai-runtime.md+++ b/docs/release-control/v6/internal/subsystems/ai-runtime.md@@ -25,6 +25,27 @@ that same result. Successful reads retain their content and execution provenance## Purpose+### Host filesystem alerts retain exact subjects in scoped Patrol++An alert-button request may name a collected child subject such as+`agent:<source-id>/disk:docker-data`. Patrol binds that reference through the+shared current-inventory resolver only when the exact collected alert identifier+and subject agree. The canonical owner becomes the collection scope. The alert+keeps its original child identity, filesystem metadata, observed value, threshold+and message in both full and budgeted model context. Related child alert evidence+is retained only for the selected current owner. Missing owners, caller-authored+child paths, names and conflicting source identities cannot broaden scope.++Linked VM, container and node owners retain their agent observations. Node/host+views of the same proven canonical owner are one identity. Automatic alert type+hints follow that owner while explicit caller type restrictions stay intact.+Admission and execution resolve independently against current collection state.+`patrol_alert_scope_test.go` covers linked owners, evidence, repeated resolution+and rejected subjects. `patrol_host_disk_scope_test.go` exercises the production+host alert evaluator and HTTP handler. The opt-in browser backend and+`scripts/check-host-disk-patrol.mjs` verify `/alerts` admission and feedback at+1440 and 390 pixels. Browser fixtures qualify admission, not model diagnosis.+### Fully cached Patrol usage — issues #2118 / #2350Zero ordinary input tokens do not mean a run was free or skipped. Any positivediff --git a/docs/release-control/v6/internal/subsystems/unified-resources.md b/docs/release-control/v6/internal/subsystems/unified-resources.mdindex e4bf9257e1..ff859e1348 100644--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@ -23,6 +23,21 @@ and sort the complete canonical change table while startup and ingestion wait.## Purpose+### Collected alert subjects share current canonical ownership++`AlertResourceReferenceResolver` exposes the current-inventory identity owner+used by history correlation to runtime consumers. Supported producer child+references bind through durable source identities only. Resolution reads the+owner, canonical type and source targets under one registry read lock. It never+uses display names or retained history aliases to resurrect a removed owner.+An agent's disk, temperature, RAID and custom observations remain owned when an+operator link folds the agent into a VM, container or node. The presence of the+agent facet is required for that cross-type ownership. Patrol can therefore+select the canonical owner without interpreting alert strings independently.+`alert_scope_test.go` verifies the registry and both read adapters, rejected+references and absent current owners. Scoped Patrol tests cover linked owners+and conflicting unqualified source IDs.+### Proxmox node temperature cell follows its own open alert — issue #2068`ProxmoxNodesTable` finds the node's own temperature alert throughdiff --git a/internal/ai/patrol_ai.go b/internal/ai/patrol_ai.goindex e8462ae8f8..b98f7cb5e3 100644--- a/internal/ai/patrol_ai.go+++ b/internal/ai/patrol_ai.go@@ -1540,6 +1540,13 @@ func buildScopeSection(scope *PatrolScope, effectiveIdentityAliases []string) stif scope.AlertIdentifier != "" {sb.WriteString(fmt.Sprintf("Alert Identifier: %s\n", scope.AlertIdentifier))}+ if ac := scope.AlertContext; ac != nil {+ sb.WriteString(fmt.Sprintf("Collected alert subject: %q (%q)\nAlert: %s %s, value %.1f, threshold %.1f\nAlert message: %q\n",+ ac.ResourceID, ac.ResourceName, ac.Level, ac.AlertType, ac.Value, ac.Threshold, ac.Message))+ if ac.Mountpoint != "" || ac.Device != "" {+ sb.WriteString(fmt.Sprintf("Alert filesystem: mountpoint %q, device %q.\n", ac.Mountpoint, ac.Device))+ }+ }if scope.FindingID != "" {sb.WriteString(fmt.Sprintf("Finding ID: %s\n", scope.FindingID))}@@ -2658,7 +2665,7 @@ func patrolActiveAlertsInScope(snap patrolRuntimeState, scopedSet map[string]boo}alerts := make([]models.Alert, 0, len(snap.ActiveAlerts))for _, alert := range snap.ActiveAlerts {- if seedIsInScope(scopedSet, alert.ResourceID) {+ if patrolAlertBelongsToScope(snap, alert.ResourceID, scopedSet) {alerts = append(alerts, alert)}}@@ -2671,7 +2678,7 @@ func patrolResolvedAlertsInScope(snap patrolRuntimeState, scopedSet map[string]b}alerts := make([]models.ResolvedAlert, 0, len(snap.RecentlyResolved))for _, resolved := range snap.RecentlyResolved {- if seedIsInScope(scopedSet, resolved.Alert.ResourceID) {+ if patrolAlertBelongsToScope(snap, resolved.Alert.ResourceID, scopedSet) {alerts = append(alerts, resolved)}}@@ -3685,16 +3692,18 @@ func (p *PatrolService) seedFindingsAndContextState(scope *PatrolScope, snap patsb.WriteString(fmt.Sprintf("- Guest Memory warning: %.0f%%\n", thresholds.GuestMemWarning))sb.WriteString(fmt.Sprintf("- Guest Disk warning: %.0f%%, critical: %.0f%%\n", thresholds.GuestDiskWarn, thresholds.GuestDiskCrit))sb.WriteString(fmt.Sprintf("- Storage warning: %.0f%%, critical: %.0f%%\n", thresholds.StorageWarning, thresholds.StorageCritical))- if scope != nil && scope.Reason == TriggerReasonAlertFired && scope.AlertContext != nil {+ if scope != nil && scope.AlertContext != nil && scope.Reason != TriggerReasonAlertCleared {ac := scope.AlertContextlevel := ac.Levelif level == "" {level = "threshold"}- sb.WriteString(fmt.Sprintf("Note: A live %s alert just fired on the scoped resource: %s = %.1f (threshold %.1f). "++ sb.WriteString(fmt.Sprintf("Note: This check investigates the collected %s alert on %q: %s = %.1f (threshold %.1f). "+"Investigate the root cause of THIS breach specifically: what changed, whether it is transient or sustained, the blast radius on dependent workloads, and the concrete remediation. "+"Reporting a finding for this breach is expected. It is the reason this patrol was triggered.\n\n",- level, ac.AlertType, ac.Value, ac.Threshold))+ level, ac.ResourceName, ac.AlertType, ac.Value, ac.Threshold))+ } else if scope != nil && scope.AlertContext != nil && scope.Reason == TriggerReasonAlertCleared {+ sb.WriteString("Note: Verify that the collected alert's breach has resolved using current evidence.\n\n")} else {sb.WriteString("Note: The real-time alerting system monitors these thresholds continuously. Do NOT report findings for threshold breaches. Focus on trends, capacity planning, and issues alerts cannot detect.\n\n")}diff --git a/internal/ai/patrol_alert_scope.go b/internal/ai/patrol_alert_scope.gonew file mode 100644index 0000000000..df425fc51e--- /dev/null+++ b/internal/ai/patrol_alert_scope.go@@ -0,0 +1,117 @@+package ai++import (+ "strings"++ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+)++// A child reference selects its owner only through an exact collected alert.+// An arbitrary caller-authored child path cannot broaden Patrol scope.+func patrolScopeAlert(state patrolRuntimeState, scope PatrolScope) *models.Alert {+ identifier := strings.TrimSpace(scope.AlertIdentifier)+ if identifier == "" {+ return nil+ }+ var found *models.Alert+ if scope.Reason != TriggerReasonAlertCleared {+ for i := range state.ActiveAlerts {+ if state.ActiveAlerts[i].ID != identifier {+ continue+ }+ if found != nil {+ return nil+ }+ alert := state.ActiveAlerts[i]+ found = &alert+ }+ if found != nil {+ return found+ }+ }+ // Recurrences reuse an alert ID. An open occurrence takes precedence;+ // after clearing, use the latest collected resolution for that ID.+ var latest *models.ResolvedAlert+ for i := range state.RecentlyResolved {+ if state.RecentlyResolved[i].Alert.ID != identifier {+ continue+ }+ candidate := &state.RecentlyResolved[i]+ if latest == nil || candidate.ResolvedTime.After(latest.ResolvedTime) {+ latest = candidate+ }+ }+ if latest == nil {+ return nil+ }+ alert := latest.Alert+ return &alert+}++func patrolAlertReferenceResolver(state patrolRuntimeState) unifiedresources.AlertResourceReferenceResolver {+ if state.alertResourceResolver != nil {+ return state.alertResourceResolver+ }+ if resolver, ok := state.readState.(unifiedresources.AlertResourceReferenceResolver); ok {+ return resolver+ }+ if resolver, ok := state.unifiedResourceProvider.(unifiedresources.AlertResourceReferenceResolver); ok {+ return resolver+ }+ registry := unifiedresources.NewRegistry(nil)+ registry.IngestSnapshot(state.resourceSnapshot())+ if state.unifiedResourceProvider != nil {+ registry.IngestResources(state.unifiedResourceProvider.GetAll())+ }+ return registry+}++func patrolAlertOwnerIDs(resolver unifiedresources.AlertResourceReferenceResolver, binding unifiedresources.AlertResourceReference) []string {+ ids := []string{binding.ResourceID}+ for _, target := range binding.SourceTargets {+ // Unqualified source IDs can collide across collectors. Only project+ // IDs that still uniquely identify this owner into the snapshot matcher.+ candidate, _ := resolver.ResolveAlertResourceReference(target.SourceID)+ if candidate.ResourceID == binding.ResourceID {+ ids = append(ids, target.SourceID)+ }+ }+ return ids+}++// Keep exact child evidence when its current owner is selected. The subject's+// original identity stays on the alert; it is not an extra scoped resource.+func patrolAlertBelongsToScope(state patrolRuntimeState, resourceID string, included map[string]bool) bool {+ if included[resourceID] {+ return true+ }+ resolver := patrolAlertReferenceResolver(state)+ binding, _ := resolver.ResolveAlertResourceReference(resourceID)+ if binding.ResourceID == "" {+ return false+ }+ if included[binding.ResourceID] {+ return true+ }+ for _, target := range binding.SourceTargets {+ if !included[target.SourceID] {+ continue+ }+ candidate, _ := resolver.ResolveAlertResourceReference(target.SourceID)+ if candidate.ResourceID == binding.ResourceID {+ return true+ }+ }+ return false+}++func patrolAlertContext(alert *models.Alert) *PatrolAlertContext {+ if alert == nil {+ return nil+ }+ metadataString := func(key string) string { value, _ := alert.Metadata[key].(string); return value }+ return &PatrolAlertContext{AlertType: alert.Type, Level: alert.Level, Value: alert.Value, Threshold: alert.Threshold,+ Message: alert.Message, ResourceID: alert.ResourceID, ResourceName: alert.ResourceName,+ Mountpoint: metadataString("mountpoint"), Device: metadataString("device")}+}diff --git a/internal/ai/patrol_alert_scope_test.go b/internal/ai/patrol_alert_scope_test.gonew file mode 100644index 0000000000..e75ed7a6e6--- /dev/null+++ b/internal/ai/patrol_alert_scope_test.go@@ -0,0 +1,169 @@+package ai++import (+ "strings"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+)++// Control: selecting a known owner must preserve the exact triggering child+// alert. This exposes why a string-prefix rewrite alone is not a complete fix.+func TestSupportHostDiskOwnerScopeRetainsTrigger(t *testing.T) {+ host := models.Host{ID: "repro-host-source-01", Hostname: "docker-host-ext-01", MachineID: "repro-machine-01", Disks: []models.Disk{{Mountpoint: "/docker-data", Usage: 85}}}+ alert := models.Alert{ID: "repro-disk-alert", ResourceID: "agent:repro-host-source-01/disk:docker-data", Type: "disk", Metadata: map[string]interface{}{"hostId": host.ID, "mountpoint": "/docker-data"}}+ snapshot := models.StateSnapshot{Hosts: []models.Host{host}, ActiveAlerts: []models.Alert{alert}}+ registry := unifiedresources.NewRegistry(nil)+ registry.IngestSnapshot(snapshot)+ for _, unified := range []bool{false, true} {+ name := "snapshot"+ state := newPatrolRuntimeState(snapshot)+ parentID := host.ID+ if unified {+ name = "unified"+ state = newPatrolRuntimeStateWithProviders(snapshot, registry, unifiedresources.NewUnifiedAIAdapter(registry))+ _, id, found := registry.GetByReference(host.ID)+ if !found {+ t.Fatal("canonical owner missing")+ }+ parentID = id+ }+ t.Run(name, func(t *testing.T) {+ resolved, resolution := resolvePatrolScopeState(state, PatrolScope{ResourceIDs: []string{parentID}, AlertIdentifier: alert.ID})+ if len(resolution.UnmatchedResourceIDs) != 0 || len(resolution.EffectiveResourceIDs) == 0 {+ t.Fatalf("owner control did not resolve: %+v", resolution)+ }+ filtered := filterPatrolStateByScopeState(state, resolved)+ t.Logf("resolved=%+v effective=%v hosts=%d active_alerts=%d", resolved, resolution.EffectiveResourceIDs, len(filtered.Hosts), len(filtered.ActiveAlerts))+ if len(filtered.ActiveAlerts) != 1 || filtered.ActiveAlerts[0].ID != alert.ID {+ t.Fatalf("owner scope discarded the exact disk alert despite AlertIdentifier=%q", alert.ID)+ }+ })+ }+}++func TestPatrolDiskAlertRecurrenceUsesCurrentEvidence(t *testing.T) {+ active := models.Alert{ID: "disk-alert", ResourceID: "agent:source-host/disk:data", Type: "disk", Value: 85, Threshold: 85}+ old := active+ old.Value = 95+ latest := active+ latest.Value = 75+ state := newPatrolRuntimeState(models.StateSnapshot{Hosts: []models.Host{{ID: "source-host", MachineID: "machine"}}, ActiveAlerts: []models.Alert{active}, RecentlyResolved: []models.ResolvedAlert{{Alert: old, ResolvedTime: time.Unix(1, 0)}, {Alert: latest, ResolvedTime: time.Unix(2, 0)}}})+ for _, tc := range []struct {+ reason TriggerReason+ value float64+ }{{TriggerReasonManual, 85}, {TriggerReasonAlertCleared, 75}} {+ resolved, resolution := resolvePatrolScopeState(state, PatrolScope{ResourceIDs: []string{active.ResourceID}, AlertIdentifier: active.ID, Reason: tc.reason})+ if len(resolution.EffectiveResourceIDs) == 0 || resolved.AlertContext == nil || resolved.AlertContext.Value != tc.value {+ t.Fatalf("wrong occurrence evidence for %s: %+v, %+v", tc.reason, resolution, resolved.AlertContext)+ }+ }+}++func TestPatrolDiskAlertOwnerAndEvidence(t *testing.T) {+ for _, ownerType := range []string{"agent", "vm", "system-container", "node"} {+ t.Run(ownerType, func(t *testing.T) {+ host := models.Host{ID: "disk-host-source", Hostname: "disk-host", MachineID: "disk-machine"}+ alert := models.Alert{ID: "disk-alert", ResourceID: "agent:disk-host-source/disk:docker-data", ResourceName: "disk-host (/docker-data)", Type: "disk", Level: "warning", Value: 85, Threshold: 85, Message: "Disk usage reached 85%", Metadata: map[string]interface{}{"mountpoint": "/docker-data", "device": "/dev/sdb1"}}+ unrelated := models.Alert{ID: "other-alert", ResourceID: "agent:other-host/disk:docker-data", Type: "disk"}+ snapshot := models.StateSnapshot{Hosts: []models.Host{host, {ID: "other-host", MachineID: "other-machine"}}, ActiveAlerts: []models.Alert{alert, unrelated}, RecentlyResolved: []models.ResolvedAlert{{Alert: alert}, {Alert: unrelated}}}+ // Keep this occurrence distinct; ID reuse is covered separately above.+ snapshot.RecentlyResolved[0].ID = "resolved-disk-alert"+ ownerSourceID := host.ID+ switch ownerType {+ case "vm":+ ownerSourceID = "vm-owner"+ snapshot.VMs = []models.VM{{ID: ownerSourceID, VMID: 101, Instance: "pve", Node: "node-owner", Name: "linked-vm"}}+ case "system-container":+ ownerSourceID = "ct-owner"+ snapshot.Containers = []models.Container{{ID: ownerSourceID, VMID: 102, Instance: "pve", Node: "node-owner", Name: "linked-container"}}+ case "node":+ ownerSourceID = "node-owner"+ snapshot.Nodes = []models.Node{{ID: ownerSourceID, Name: "linked-node", Instance: "pve"}}+ }+ store := unifiedresources.NewMemoryStore()+ registry := unifiedresources.NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ _, hostID, hostFound := registry.GetByReference(host.ID)+ _, ownerID, ownerFound := registry.GetByReference(ownerSourceID)+ if !hostFound || !ownerFound {+ t.Fatal("fixture owner missing")+ }+ if ownerType != "agent" {+ if err := store.AddLink(unifiedresources.ResourceLink{ResourceA: hostID, ResourceB: ownerID, PrimaryID: ownerID}); err != nil {+ t.Fatal(err)+ }+ registry = unifiedresources.NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ }+ state := newPatrolRuntimeStateWithProviders(snapshot, registry, unifiedresources.NewUnifiedAIAdapter(registry))+ for _, scope := range []PatrolScope{+ {ResourceIDs: []string{alert.ResourceID}, AlertIdentifier: alert.ID, Reason: TriggerReasonManual},+ AlertTriggeredPatrolScope(alert.ID, alert.ResourceID, "agent", "disk"),+ AlertClearedPatrolScope("resolved-disk-alert", alert.ResourceID, "agent"),+ } {+ resolved, resolution := resolvePatrolScopeState(state, scope)+ if len(resolution.UnmatchedResourceIDs)+len(resolution.AmbiguousResourceIDs) != 0 || len(resolution.EffectiveResourceIDs) == 0 {+ t.Fatalf("%s admission failed: %+v", scope.Reason, resolution)+ }+ // Admission and execution each resolve against current inventory.+ resolved, resolution = resolvePatrolScopeState(state, resolved)+ if len(resolution.UnmatchedResourceIDs)+len(resolution.AmbiguousResourceIDs) != 0 || len(resolution.EffectiveResourceIDs) == 0 {+ t.Fatalf("%s execution failed: %+v", scope.Reason, resolution)+ }+ filtered := filterPatrolStateByScopeState(state, resolved)+ if len(filtered.ActiveAlerts) != 1 || filtered.ActiveAlerts[0].ResourceID != alert.ResourceID || len(filtered.RecentlyResolved) != 1 {+ t.Fatalf("lost subject or leaked neighbor evidence: %+v", filtered.ActiveAlerts)+ }+ if resource := filtered.unifiedResourceProvider.GetAll(); len(resource) != 1 || resource[0].ID != ownerID {+ t.Fatalf("scope expanded beyond canonical owner: %+v", resource)+ }+ if resolved.AlertContext == nil || resolved.AlertContext.ResourceID != alert.ResourceID || resolved.AlertContext.Value != 85 || resolved.AlertContext.Threshold != 85 {+ t.Fatalf("lost trusted alert evidence: %+v", resolved.AlertContext)+ }+ prompt := buildScopeSection(&resolved, resolution.EffectiveResourceIDs)+ for _, evidence := range []string{alert.ResourceID, "/docker-data", "/dev/sdb1", "value 85.0, threshold 85.0", alert.Message} {+ if !strings.Contains(prompt, evidence) {+ t.Fatalf("missing %q in prompt: %s", evidence, prompt)+ }+ }+ }+ })+ }+}++func TestPatrolDiskAlertRejectsUntrustedSubjects(t *testing.T) {+ for _, scenario := range []string{"missing-alert", "wrong-alert", "duplicate-alert", "wrong-subject", "removed-owner", "display-name-owner", "malformed-child", "source-collision"} {+ t.Run(scenario, func(t *testing.T) {+ alert := models.Alert{ID: "disk-alert", ResourceID: "agent:disk-host-source/disk:docker-data", Type: "disk"}+ snapshot := models.StateSnapshot{Hosts: []models.Host{{ID: "disk-host-source", Hostname: "disk-host", MachineID: "machine"}}, ActiveAlerts: []models.Alert{alert}}+ scope := PatrolScope{ResourceIDs: []string{alert.ResourceID}, AlertIdentifier: alert.ID, AlertContext: &PatrolAlertContext{Message: "caller-authored"}}+ switch scenario {+ case "missing-alert":+ snapshot.ActiveAlerts = nil+ case "wrong-alert":+ scope.AlertIdentifier = "different-alert"+ case "duplicate-alert":+ snapshot.ActiveAlerts = append(snapshot.ActiveAlerts, alert)+ case "wrong-subject":+ scope.ResourceIDs[0] = "agent:disk-host-source/disk:other"+ case "removed-owner":+ snapshot.Hosts = nil+ case "display-name-owner":+ snapshot.ActiveAlerts[0].ResourceID = "agent:disk-host/disk:docker-data"+ scope.ResourceIDs[0] = snapshot.ActiveAlerts[0].ResourceID+ case "malformed-child":+ snapshot.ActiveAlerts[0].ResourceID += "/nested"+ scope.ResourceIDs[0] = snapshot.ActiveAlerts[0].ResourceID+ case "source-collision":+ snapshot.Nodes = []models.Node{{ID: "disk-host-source", Name: "unrelated-node", Instance: "pve"}}+ }+ resolved, resolution := resolvePatrolScopeState(newPatrolRuntimeState(snapshot), scope)+ if len(resolution.UnmatchedResourceIDs)+len(resolution.AmbiguousResourceIDs) != 1 || len(resolution.EffectiveResourceIDs) != 0 || resolved.AlertContext != nil {+ t.Fatalf("unsafe scope accepted: %+v, context=%+v", resolution, resolved.AlertContext)+ }+ })+ }+}diff --git a/internal/ai/patrol_run.go b/internal/ai/patrol_run.goindex db7c3decc2..63250c668e 100644--- a/internal/ai/patrol_run.go+++ b/internal/ai/patrol_run.go@@ -1857,20 +1857,20 @@ func patrolKubernetesScopeName(k models.KubernetesCluster) string {return clusterName}-func collectPatrolScopedActiveAlerts(alerts []models.Alert, includedResourceIDs map[string]bool) []models.Alert {+func collectPatrolScopedActiveAlerts(state patrolRuntimeState, alerts []models.Alert, includedResourceIDs map[string]bool) []models.Alert {filtered := make([]models.Alert, 0, len(alerts))for _, alert := range alerts {- if includedResourceIDs[alert.ResourceID] {+ if patrolAlertBelongsToScope(state, alert.ResourceID, includedResourceIDs) {filtered = append(filtered, alert)}}return filtered}-func collectPatrolScopedResolvedAlerts(alerts []models.ResolvedAlert, includedResourceIDs map[string]bool) []models.ResolvedAlert {+func collectPatrolScopedResolvedAlerts(state patrolRuntimeState, alerts []models.ResolvedAlert, includedResourceIDs map[string]bool) []models.ResolvedAlert {filtered := make([]models.ResolvedAlert, 0, len(alerts))for _, resolved := range alerts {- if includedResourceIDs[resolved.ResourceID] {+ if patrolAlertBelongsToScope(state, resolved.ResourceID, includedResourceIDs) {filtered = append(filtered, resolved)}}@@ -1930,10 +1930,10 @@ func collectPatrolScopedPBSBackups(backups []models.PBSBackup, includedGuestVMIDfunc copyScopedPatrolMetadata(dst *patrolRuntimeState, snap patrolRuntimeState, includedResourceIDs map[string]bool, includedGuestVMIDs map[int]bool) {if len(snap.ActiveAlerts) > 0 {- dst.ActiveAlerts = collectPatrolScopedActiveAlerts(snap.ActiveAlerts, includedResourceIDs)+ dst.ActiveAlerts = collectPatrolScopedActiveAlerts(snap, snap.ActiveAlerts, includedResourceIDs)}if len(snap.RecentlyResolved) > 0 {- dst.RecentlyResolved = collectPatrolScopedResolvedAlerts(snap.RecentlyResolved, includedResourceIDs)+ dst.RecentlyResolved = collectPatrolScopedResolvedAlerts(snap, snap.RecentlyResolved, includedResourceIDs)}if len(snap.ConnectionHealth) > 0 {dst.ConnectionHealth = collectPatrolScopedConnectionHealth(snap.ConnectionHealth, includedResourceIDs)@@ -1949,6 +1949,9 @@ func copyScopedPatrolMetadata(dst *patrolRuntimeState, snap patrolRuntimeState,}func filterPatrolStateByScopeState(snap patrolRuntimeState, scope PatrolScope) patrolRuntimeState {+ if len(snap.ActiveAlerts)+len(snap.RecentlyResolved) > 0 {+ snap.alertResourceResolver = patrolAlertReferenceResolver(snap)+ }matcher := newPatrolScopeMatcher(scope)filterState := newPatrolScopedFilterState(snap)@@ -2006,6 +2009,9 @@ func filterPatrolStateByScopeState(snap patrolRuntimeState, scope PatrolScope) p// context.filteredUnified, unifiedIDs := collectPatrolScopedUnifiedResources(snap.unifiedResourceProvider, matcher)filterState.includeResourceID(unifiedIDs...)+ if len(filteredUnified) > 0 {+ filterState.filtered.alertResourceResolver = patrolAlertReferenceResolver(snap)+ }copyScopedPatrolMetadata(&filterState.filtered, snap, filterState.includedResourceIDs, filterState.includedGuestVMIDs)diff --git a/internal/ai/patrol_state.go b/internal/ai/patrol_state.goindex 4b8b3d9b52..e913cedf29 100644--- a/internal/ai/patrol_state.go+++ b/internal/ai/patrol_state.go@@ -77,6 +77,7 @@ type patrolRuntimeResourceRecord struct {// It intentionally includes only the fields patrol currently consumes, so the// subsystem can stop mirroring the full global StateSnapshot shape.type patrolRuntimeState struct {+ alertResourceResolver unifiedresources.AlertResourceReferenceResolverreadState unifiedresources.ReadStateunifiedResourceProvider UnifiedResourceProviderNodes []models.Node@@ -170,7 +171,39 @@ func (s patrolRuntimeState) withDerivedProvidersAndResources(resources []unifiedregistry := unifiedresources.NewRegistry(nil)registry.IngestSnapshot(s.resourceSnapshot())if len(resources) > 0 {- registry.IngestResources(resources)+ // Already-unified rows own their source observations. Re-ingesting a+ // linked agent snapshot without its operator link would invent a second+ // host beside the canonical guest/node. Keep only supplemental snapshot+ // rows whose source observations are not already fully represented.+ resolver := patrolAlertReferenceResolver(s)+ type sourceKey struct {+ source unifiedresources.DataSource+ id string+ }+ covered := make(map[sourceKey]bool)+ for _, resource := range resources {+ binding, _ := resolver.ResolveAlertResourceReference(resource.ID)+ for _, target := range binding.SourceTargets {+ covered[sourceKey{target.Source, target.SourceID}] = true+ }+ }+ retained := make([]unifiedresources.Resource, 0)+ bindings := registry.AlertResourceReferences()+ for _, resource := range registry.List() {+ targets := bindings[resource.ID].SourceTargets+ fullyCovered := len(targets) > 0+ for _, target := range targets {+ if !covered[sourceKey{target.Source, target.SourceID}] {+ fullyCovered = false+ break+ }+ }+ if !fullyCovered {+ retained = append(retained, resource)+ }+ }+ registry = unifiedresources.NewRegistry(nil)+ registry.IngestResources(append(retained, resources...))}s.readState = registrys.unifiedResourceProvider = unifiedresources.NewUnifiedAIAdapter(registry)@@ -540,10 +573,23 @@ func canonicalPatrolRuntimeResourceType(kind patrolRuntimeResourceKind) string {// unique known aliases onto the complete identity set for the matching Patrol// runtime record. It never fuzzy-matches and refuses ambiguous aliases.func resolvePatrolScopeState(state patrolRuntimeState, scope PatrolScope) (PatrolScope, PatrolScopeResolution) {+ if scope.AlertIdentifier != "" {+ scope.AlertContext = nil+ state.alertResourceResolver = patrolAlertReferenceResolver(state)+ }// Recompute private type evidence from the current runtime snapshot on every// resolution pass; callers may synchronously pre-resolve and the accepted run// resolves again to close collection races.scope.resolvedResourceTypes = nil+ alert := patrolScopeAlert(state, scope)+ var alertOwner unifiedresources.AlertResourceReference+ var alertOwnerIDs []string+ if alert != nil {+ alertOwner, _ = patrolAlertReferenceResolver(state).ResolveAlertResourceReference(alert.ResourceID)+ if alertOwner.ResourceID != "" {+ alertOwnerIDs = patrolAlertOwnerIDs(patrolAlertReferenceResolver(state), alertOwner)+ }+ }resolution := PatrolScopeResolution{}for _, requested := range scope.ResourceIDs {if requested = strings.TrimSpace(requested); requested != "" {@@ -628,21 +674,72 @@ func resolvePatrolScopeState(state patrolRuntimeState, scope PatrolScope) (Patro}}}- switch len(matches) {- case 0:+ if len(matches) == 0 && alert != nil && alertOwner.ResourceID != "" {+ requestedAlertIdentity := requested == alert.ResourceID+ for _, ownerID := range alertOwnerIDs {+ requestedAlertIdentity = requestedAlertIdentity || requested == ownerID+ }+ if requestedAlertIdentity {+ for _, ownerID := range alertOwnerIDs {+ for _, record := range records {+ if record.idTokens[canonicalPatrolScopeToken(ownerID)] {+ matches = append(matches, record)+ }+ }+ if len(matches) > 0 {+ break+ }+ }+ }+ }+ // A linked node may expose both node and host views of one canonical+ // resource. Only collected-alert ownership can prove those facets are+ // the same identity; unrelated ID/alias collisions remain ambiguous.+ sameAlertOwner := alertOwner.ResourceID != "" && len(matches) > 0+ if sameAlertOwner {+ for _, record := range matches {+ owner, _ := patrolAlertReferenceResolver(state).ResolveAlertResourceReference(record.ids[0])+ if owner.ResourceID != alertOwner.ResourceID {+ sameAlertOwner = false+ break+ }+ }+ }+ switch {+ case len(matches) == 0:resolution.UnmatchedResourceIDs = append(resolution.UnmatchedResourceIDs, requested)- case 1:- for _, id := range matches[0].ids {- addExpanded(id)- addResolved(id)+ case len(matches) == 1 || sameAlertOwner:+ for _, record := range matches {+ for _, id := range record.ids {+ addExpanded(id)+ addResolved(id)+ }+ addResolvedType(record.resourceType)+ }+ if sameAlertOwner {+ for _, id := range alertOwnerIDs {+ addExpanded(id)+ addResolved(id)+ }}- addResolvedType(matches[0].resourceType)default:resolution.AmbiguousResourceIDs = append(resolution.AmbiguousResourceIDs, requested)}}scope.ResourceIDs = expandedscope.resolvedIdentityOnly = len(expanded) > 0+ if alert != nil {+ included := make(map[string]bool, len(expanded))+ for _, id := range expanded {+ included[id] = true+ }+ if patrolAlertBelongsToScope(state, alert.ResourceID, included) {+ scope.AlertContext = patrolAlertContext(alert)+ if scope.alertResourceTypeHint {+ scope.ResourceTypes = append([]string(nil), scope.resolvedResourceTypes...)+ }+ }+ }if len(expanded) > 0 {filtered := filterPatrolStateByScopeState(state, scope)resolution.EffectiveResourceIDs = patrolRuntimeSortedResourceIDs(filtered)diff --git a/internal/ai/patrol_triggers.go b/internal/ai/patrol_triggers.goindex f6043225ac..88b92f0409 100644--- a/internal/ai/patrol_triggers.go+++ b/internal/ai/patrol_triggers.go@@ -108,6 +108,9 @@ type PatrolScope struct {// scopes. It is used only to reduce the provider tool manifest; it never// broadens collection scope or mutation authority.resolvedResourceTypes []string+ // Alert constructors receive the producer's type hint. Current canonical+ // ownership can replace that hint when an agent is linked into a guest/node.+ alertResourceTypeHint bool}// PatrolScopeResolution records how caller-supplied identities map onto the@@ -123,11 +126,15 @@ type PatrolScopeResolution struct {// PatrolAlertContext describes the alert that triggered a scoped patrol, so the// patrol prompt can focus the investigation on the specific breach.type PatrolAlertContext struct {- AlertType string // cpu, memory, disk, etc.- Level string // warning | critical- Value float64 // observed metric value at fire time- Threshold float64 // threshold that was crossed- Message string // human-readable alert message+ ResourceID string+ ResourceName string+ Mountpoint string+ Device string+ AlertType string // cpu, memory, disk, etc.+ Level string // warning | critical+ Value float64 // observed metric value at fire time+ Threshold float64 // threshold that was crossed+ Message string // human-readable alert message}// PatrolDepth controls how thorough a patrol run should be@@ -693,26 +700,28 @@ func patrolScopeResourceTypes(resourceType string) []string {// AlertTriggeredPatrolScope creates a patrol scope for an alert that firedfunc AlertTriggeredPatrolScope(alertIdentifier, resourceID, resourceType, alertType string) PatrolScope {return PatrolScope{- ResourceIDs: []string{resourceID},- ResourceTypes: patrolScopeResourceTypes(resourceType),- Depth: PatrolDepthQuick,- Reason: TriggerReasonAlertFired,- Context: "Alert: " + alertType,- Priority: triggerPriorityAlertFired,- AlertIdentifier: alertIdentifier,+ ResourceIDs: []string{resourceID},+ ResourceTypes: patrolScopeResourceTypes(resourceType),+ Depth: PatrolDepthQuick,+ Reason: TriggerReasonAlertFired,+ Context: "Alert: " + alertType,+ Priority: triggerPriorityAlertFired,+ AlertIdentifier: alertIdentifier,+ alertResourceTypeHint: true,}}// AlertClearedPatrolScope creates a patrol scope for an alert that clearedfunc AlertClearedPatrolScope(alertIdentifier, resourceID, resourceType string) PatrolScope {return PatrolScope{- ResourceIDs: []string{resourceID},- ResourceTypes: patrolScopeResourceTypes(resourceType),- Depth: PatrolDepthQuick,- Reason: TriggerReasonAlertCleared,- Context: "Verify resolution",- Priority: triggerPriorityAlertCleared,- AlertIdentifier: alertIdentifier,+ ResourceIDs: []string{resourceID},+ ResourceTypes: patrolScopeResourceTypes(resourceType),+ Depth: PatrolDepthQuick,+ Reason: TriggerReasonAlertCleared,+ Context: "Verify resolution",+ Priority: triggerPriorityAlertCleared,+ AlertIdentifier: alertIdentifier,+ alertResourceTypeHint: true,}}diff --git a/internal/api/patrol_host_disk_scope_test.go b/internal/api/patrol_host_disk_scope_test.gonew file mode 100644index 0000000000..1bbd9c0f32--- /dev/null+++ b/internal/api/patrol_host_disk_scope_test.go@@ -0,0 +1,197 @@+package api++import (+ "bytes"+ "encoding/json"+ "net"+ "net/http"+ "net/http/httptest"+ "os"+ "strings"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/ai"+ "github.com/rcourtman/pulse-go-rewrite/internal/alerts"+ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+)++// Reproduce the alert button's exact request using a disk alert emitted by+// CheckHost. Keep Patrol busy so successful identity admission cannot call a+// model or start a background run. A valid identity must reach the busy guard.+func TestSupportHostDiskInvestigationContract(t *testing.T) {+ for _, linked := range []bool{false, true} {+ for _, unified := range []bool{false, true} {+ name := "snapshot"+ if unified {+ name = "unified"+ }+ if linked {+ name += "-linked-vm"+ } else {+ name += "-standalone"+ }+ t.Run(name, func(t *testing.T) {+ host := models.Host{+ ID: "repro-host-source-01", Hostname: "docker-host-ext-01",+ DisplayName: "docker-host-ext-01", Status: "online",+ MachineID: "repro-machine-01", LastSeen: time.Now(),+ Disks: []models.Disk{{Mountpoint: "/docker-data", Device: "/dev/sdb1", Usage: 85, Total: 1000, Used: 850, Free: 150}},+ }+ snapshot := models.StateSnapshot{Hosts: []models.Host{host, {+ ID: "unrelated-host", Hostname: "unrelated", MachineID: "unrelated-machine", Status: "online",+ }}}+ if linked {+ host.LinkedVMID = "vm-101"+ snapshot.Hosts[0] = host+ snapshot.VMs = []models.VM{{ID: "vm-101", Name: host.Hostname, VMID: 101, Node: "pve-1", Instance: "pve", Status: "running"}}+ }+ manager := alerts.NewManagerWithDataDir(t.TempDir(), alerts.WithoutPersistedAlertRestore())+ t.Cleanup(manager.Stop)+ // The production evaluator is unchanged; only temporal delay and+ // unrelated default policies are disabled for this immediate proof.+ setUnexportedField(t, manager, "config", alerts.AlertConfig{+ Enabled: true, ActivationState: alerts.ActivationActive,+ AgentDefaults: alerts.ThresholdConfig{Disk: &alerts.HysteresisThreshold{Trigger: 85, Clear: 80}},+ Overrides: map[string]alerts.ThresholdConfig{}, TimeThresholds: map[string]int{},+ })+ manager.CheckHost(host)+ active := manager.GetActiveAlerts()+ if len(active) != 1 {+ t.Fatalf("disk fixture did not produce exactly one alert: %+v", active)+ }+ alert := active[0]+ if alert.ResourceID != "agent:repro-host-source-01/disk:docker-data" || alert.Type != "disk" {+ t.Fatalf("unexpected emitted disk identity: %+v", alert)+ }+ t.Logf("emitted resource_id=%q resource_name=%q hostId=%v mountpoint=%v", alert.ResourceID, alert.ResourceName, alert.Metadata["hostId"], alert.Metadata["mountpoint"])+ snapshot.ActiveAlerts = []models.Alert{hostDiskPatrolStateAlert(alert)}+ handler, patrol, _, _ := setupAIHandlerWithPatrol(t)+ seedReadyAnthropicPatrolRuntime(t, handler)+ handler.defaultAIService.SetStateProvider(&scopedPatrolStateProvider{state: snapshot})+ parentID := host.ID+ if unified {+ store := unifiedresources.NewMemoryStore()+ registry := unifiedresources.NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ if linked {+ _, hostCanonicalID, hostFound := registry.GetByReference(host.ID)+ _, vmCanonicalID, vmFound := registry.GetByReference("vm-101")+ if !hostFound || !vmFound {+ t.Fatal("manual-link fixture is missing a source")+ }+ if err := store.AddLink(unifiedresources.ResourceLink{ResourceA: hostCanonicalID, ResourceB: vmCanonicalID, PrimaryID: vmCanonicalID}); err != nil {+ t.Fatal(err)+ }+ registry = unifiedresources.NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ _, foldedOwner, found := registry.GetByReference(host.ID)+ if !found || foldedOwner != vmCanonicalID {+ t.Fatalf("fixture host did not merge into VM: %q want %q", foldedOwner, vmCanonicalID)+ }+ t.Logf("manual-link host=%q folded into VM=%q", hostCanonicalID, foldedOwner)+ }+ handler.defaultAIService.SetReadState(registry)+ patrol.SetUnifiedResourceProvider(unifiedresources.NewUnifiedAIAdapter(registry))+ resource, canonicalID, ok := registry.GetByReference(host.ID)+ if !ok {+ t.Fatalf("host source identity missing from canonical registry")+ }+ parentID = canonicalID+ t.Logf("canonical owner id=%q type=%q aliases=%+v sources=%+v", canonicalID, resource.Type, resource.Canonical, registry.SourceTargets(canonicalID))+ if _, _, ok := registry.GetByReference(alert.ResourceID); ok {+ t.Log("disk alert unexpectedly has a canonical registry resource")+ }+ }+ _, parentResolution := patrol.ResolvePatrolScope(ai.PatrolScope{ResourceIDs: []string{parentID}})+ if len(parentResolution.UnmatchedResourceIDs) != 0 || len(parentResolution.AmbiguousResourceIDs) != 0 || len(parentResolution.EffectiveResourceIDs) == 0 {+ t.Fatalf("parent control did not resolve: %+v", parentResolution)+ }+ t.Logf("parent control resolution=%+v", parentResolution)+ _, diskResolution := patrol.ResolvePatrolScope(ai.PatrolScope{ResourceIDs: []string{alert.ResourceID}, AlertIdentifier: alert.ID})+ t.Logf("disk resolution=%+v", diskResolution)+ setUnexportedField(t, patrol, "runInProgress", true)+ setUnexportedField(t, patrol, "currentRunID", "repro-busy-sentinel")+ request := func(resourceID string) *httptest.ResponseRecorder {+ body, err := json.Marshal(map[string]any{"resource_ids": []string{resourceID}, "alert_identifier": alert.ID, "alert_type": alert.Type})+ if err != nil {+ t.Fatal(err)+ }+ rec := httptest.NewRecorder()+ handler.HandleForcePatrol(rec, newLoopbackRequest(http.MethodPost, "/api/ai/patrol/run", bytes.NewReader(body)))+ return rec+ }+ control := request(parentID)+ if control.Code != http.StatusConflict || !strings.Contains(control.Body.String(), "patrol_already_running") {+ t.Fatalf("known parent did not reach downstream busy guard: %d %s", control.Code, control.Body.String())+ }+ rec := request(alert.ResourceID)+ t.Logf("disk HTTP status=%d body=%s", rec.Code, rec.Body.String())+ if rec.Code != http.StatusConflict || !strings.Contains(rec.Body.String(), "patrol_already_running") {+ t.Fatalf("disk alert must resolve before busy admission, got %d %s", rec.Code, rec.Body.String())+ }+ })+ }+ }+}++// Opt-in loopback backend for scripts/check-host-disk-patrol.mjs. The browser+// exercises the real admission handler against a production-emitted alert.+// Inference is absent, so acceptance is not a claim of completed diagnosis.+func TestPatrolHostDiskBrowserBackend(t *testing.T) {+ address := os.Getenv("PULSE_HOST_DISK_BROWSER_ADDRESS")+ if address == "" {+ t.Skip("opt-in browser admission fixture")+ }+ hostIP, _, err := net.SplitHostPort(address)+ if err != nil || hostIP != "127.0.0.1" {+ t.Fatal("browser fixture requires a loopback address")+ }+ host := models.Host{ID: "repro-host-source-01", Hostname: "docker-host-ext-01", MachineID: "repro-machine-01", Status: "online", LastSeen: time.Now(), Disks: []models.Disk{{Mountpoint: "/docker-data", Device: "/dev/sdb1", Usage: 85, Total: 1000, Used: 850, Free: 150}}}+ manager := alerts.NewManagerWithDataDir(t.TempDir(), alerts.WithoutPersistedAlertRestore())+ t.Cleanup(manager.Stop)+ setUnexportedField(t, manager, "config", alerts.AlertConfig{Enabled: true, ActivationState: alerts.ActivationActive, AgentDefaults: alerts.ThresholdConfig{Disk: &alerts.HysteresisThreshold{Trigger: 85, Clear: 80}}, Overrides: map[string]alerts.ThresholdConfig{}, TimeThresholds: map[string]int{}})+ manager.CheckHost(host)+ active := manager.GetActiveAlerts()+ if len(active) != 1 {+ t.Fatalf("fixture alert missing: %+v", active)+ }+ stop := make(chan struct{}, 1)+ mux := http.NewServeMux()+ mux.HandleFunc("/proof/alert", func(w http.ResponseWriter, r *http.Request) { _ = json.NewEncoder(w).Encode(active[0]) })+ mux.HandleFunc("/proof/stop", func(w http.ResponseWriter, r *http.Request) { stop <- struct{}{} })+ mux.HandleFunc("/api/ai/patrol/run", func(w http.ResponseWriter, r *http.Request) {+ handler, patrol, _, _ := setupAIHandlerWithPatrol(t)+ seedReadyAnthropicPatrolRuntime(t, handler)+ handler.defaultAIService.SetChatService(nil)+ snapshot := models.StateSnapshot{Hosts: []models.Host{host}, ActiveAlerts: []models.Alert{hostDiskPatrolStateAlert(active[0])}}+ if r.URL.Query().Get("case") == "unresolved" {+ snapshot.Hosts = nil+ }+ handler.defaultAIService.SetStateProvider(&scopedPatrolStateProvider{state: snapshot})+ if r.URL.Query().Get("case") == "busy" {+ setUnexportedField(t, patrol, "runInProgress", true)+ setUnexportedField(t, patrol, "currentRunID", "browser-busy")+ }+ handler.HandleForcePatrol(w, r)+ })+ listener, err := net.Listen("tcp", address)+ if err != nil {+ t.Fatal(err)+ }+ server := httptest.NewUnstartedServer(mux)+ server.Listener = listener+ server.Start()+ t.Cleanup(server.Close)+ t.Logf("browser admission fixture ready at %s", server.URL)+ select {+ case <-stop:+ case <-time.After(4 * time.Minute):+ t.Fatal("browser fixture was not stopped")+ }+}++func hostDiskPatrolStateAlert(alert alerts.Alert) models.Alert {+ return models.Alert{ID: alert.ID, Type: alert.Type, Level: string(alert.Level), ResourceID: alert.ResourceID, ResourceName: alert.ResourceName, Message: alert.Message, Value: alert.Value, Threshold: alert.Threshold, StartTime: alert.StartTime, Metadata: alert.Metadata}+}diff --git a/internal/unifiedresources/history_identity.go b/internal/unifiedresources/history_identity.goindex 3cb351ee8d..5c9ea41a1d 100644--- a/internal/unifiedresources/history_identity.go+++ b/internal/unifiedresources/history_identity.go@@ -10,6 +10,76 @@ import ("time")+// AlertResourceReference binds a collected alert subject to current canonical+// inventory. Source targets are durable identities, never display names.+type AlertResourceReference struct {+ ResourceID string+ ResourceType ResourceType+ SourceTargets []SourceTarget+}++type AlertResourceReferenceResolver interface {+ ResolveAlertResourceReference(string) (AlertResourceReference, bool)+}++// AlertResourceReferences captures current source ownership in one generation.+// Scoped projections use this batch view instead of scanning every source+// mapping once per resource when rebuilding a read-only registry.+func (rr *ResourceRegistry) AlertResourceReferences() map[string]AlertResourceReference {+ if rr == nil {+ return nil+ }+ rr.mu.RLock()+ defer rr.mu.RUnlock()+ targets := rr.cachedSourceTargets+ if rr.viewsDirty || targets == nil {+ targets = rr.buildSourceTargetsIndexLocked()+ }+ bindings := make(map[string]AlertResourceReference, len(rr.resources))+ for id, resource := range rr.resources {+ bindings[id] = AlertResourceReference{ResourceID: id, ResourceType: resource.Type, SourceTargets: append([]SourceTarget(nil), targets[id]...)}+ }+ return bindings+}++// ResolveAlertResourceReference shares current-inventory identity with history+// correlation. It never consults retained history bindings or matches names.+// claimed is true for an inventory conflict as well as a successful binding;+// conflicts have an empty ResourceID and must not fall back to another source.+func (rr *ResourceRegistry) ResolveAlertResourceReference(ref string) (AlertResourceReference, bool) {+ if rr == nil {+ return AlertResourceReference{}, false+ }+ rr.mu.RLock()+ defer rr.mu.RUnlock()+ id, claimed := rr.resolveHistoryReferenceLocked(ref)+ if id == "" {+ return AlertResourceReference{}, claimed+ }+ resource := rr.resources[id]+ if resource == nil {+ return AlertResourceReference{}, true+ }+ var targets []SourceTarget+ if !rr.viewsDirty && rr.cachedSourceTargets != nil {+ targets = append([]SourceTarget(nil), rr.cachedSourceTargets[id]...)+ } else {+ targets = rr.collectSourceTargetsLocked(id, resource.Type)+ }+ return AlertResourceReference{ResourceID: id, ResourceType: resource.Type, SourceTargets: targets}, true+}++func (a *UnifiedAIAdapter) ResolveAlertResourceReference(ref string) (AlertResourceReference, bool) {+ if a == nil || a.registry == nil {+ return AlertResourceReference{}, false+ }+ return a.registry.ResolveAlertResourceReference(ref)+}++func (a *MonitorAdapter) ResolveAlertResourceReference(ref string) (AlertResourceReference, bool) {+ return a.currentRegistry().ResolveAlertResourceReference(ref)+}+// legacyDockerHistoryIdentity accepts the source identifier emitted by Docker// alerts only when it contains a complete container ID. Names and short IDs// cannot establish durable identity after inventory removal.@@ -128,7 +198,7 @@ func historySubResourceOwner(ref string) (ownerRef string, ownerType ResourceTypif rest, found := strings.CutPrefix(ref, "agent:"); found {hostID, child, _ := strings.Cut(rest, "/")kind, label, _ := strings.Cut(child, ":")- if hostID == "" || label == "" {+ if hostID == "" || label == "" || strings.ContainsAny(label, "/\\") {return "", "", false}switch kind {@@ -160,12 +230,19 @@ func historySubResourceOwner(ref string) (ownerRef string, ownerType ResourceTyp// possibly ambiguously; an ambiguous or conflicting reference resolves to// nothing and must not follow a retained binding.func (rr *ResourceRegistry) resolveHistoryReference(ref string) (resourceID string, claimed bool) {- ref = CanonicalResourceID(ref)- if rr == nil || ref == "" {+ if rr == nil {return "", false}rr.mu.RLock()defer rr.mu.RUnlock()+ return rr.resolveHistoryReferenceLocked(ref)+}++func (rr *ResourceRegistry) resolveHistoryReferenceLocked(ref string) (resourceID string, claimed bool) {+ ref = CanonicalResourceID(ref)+ if ref == "" {+ return "", false+ }if isDockerHistoryReference(ref) {resourceID = rr.dockerHistoryOwnerLocked(ref)return resourceID, resourceID != ""@@ -181,7 +258,11 @@ func (rr *ResourceRegistry) resolveHistoryReference(ref string) (resourceID stri// conflict: the event keeps its own reference.owners := rr.durableHistoryMatchesLocked(ownerRef)for id := range owners {- if len(owners) != 1 || CanonicalResourceType(rr.resources[id].Type) != ownerType {+ owner := rr.resources[id]+ // A linked agent retains ownership of its disk/sensor observations+ // when its canonical resource is a VM, container or node.+ typeMatches := CanonicalResourceType(owner.Type) == ownerType || (ownerType == ResourceTypeAgent && owner.Agent != nil)+ if len(owners) != 1 || !typeMatches {return "", true}matches[id] = struct{}{}diff --git a/internal/unifiedresources/history_identity_test.go b/internal/unifiedresources/history_identity_test.goindex 39d0ff5ce7..95a303ab0f 100644--- a/internal/unifiedresources/history_identity_test.go+++ b/internal/unifiedresources/history_identity_test.go@@ -858,3 +858,53 @@ func TestProxmoxPhysicalDiskAlertReferenceShape(t *testing.T) {require.Nil(t, ProxmoxPhysicalDiskAlertIdentifiers(ref), ref)}}++func TestAlertResourceReferenceRequiresCurrentDurableOwner(t *testing.T) {+ snapshot := models.StateSnapshot{Hosts: []models.Host{{ID: "host-source", Hostname: "display-name", MachineID: "machine"}}}+ registry := NewRegistry(nil)+ registry.IngestSnapshot(snapshot)+ _, ownerID, found := registry.GetByReference("host-source")+ if !found {+ t.Fatal("fixture owner missing")+ }+ for _, resolver := range []AlertResourceReferenceResolver{registry, NewUnifiedAIAdapter(registry), NewMonitorAdapter(registry)} {+ binding, claimed := resolver.ResolveAlertResourceReference("agent:host-source/disk:docker-data")+ if !claimed || binding.ResourceID != ownerID || binding.ResourceType != ResourceTypeAgent || len(binding.SourceTargets) == 0 {+ t.Fatalf("lost canonical owner/source: %+v, claimed=%v", binding, claimed)+ }+ for _, ref := range []string{"agent:display-name/disk:docker-data", "agent:host-source/disk:", "agent:host-source/disk:data/nested", "agent:host-source/service:sshd", "agent:removed/disk:data"} {+ if binding, _ := resolver.ResolveAlertResourceReference(ref); binding.ResourceID != "" {+ t.Fatalf("bound untrusted reference %q: %+v", ref, binding)+ }+ }+ }+ // A fresh collection without the owner cannot borrow retained history.+ removed := NewRegistry(nil)+ if binding, _ := removed.ResolveAlertResourceReference("agent:host-source/disk:docker-data"); binding.ResourceID != "" {+ t.Fatalf("removed owner resolved: %+v", binding)+ }+}++func TestHistoryIdentityLinkedAgentDiskUsesCanonicalOwner(t *testing.T) {+ store := NewMemoryStore()+ snapshot := models.StateSnapshot{+ Hosts: []models.Host{{ID: "host-source", MachineID: "machine"}},+ VMs: []models.VM{{ID: "vm-source", VMID: 101, Instance: "pve", Node: "node"}},+ }+ registry := NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ _, hostID, hostFound := registry.GetByReference("host-source")+ _, vmID, vmFound := registry.GetByReference("vm-source")+ require.True(t, hostFound)+ require.True(t, vmFound)+ require.NoError(t, store.AddLink(ResourceLink{ResourceA: hostID, ResourceB: vmID, PrimaryID: vmID}))+ registry = NewRegistry(store)+ registry.IngestSnapshot(snapshot)+ ownerID, claimed := registry.resolveHistoryReference("agent:host-source/disk:data")+ require.True(t, claimed)+ require.Equal(t, vmID, ownerID)+ for _, ref := range []string{"agent:host-source/disk:data/nested", "agent:missing/disk:data"} {+ ownerID, _ := registry.resolveHistoryReference(ref)+ require.Empty(t, ownerID, ref)+ }+}diff --git a/scripts/check-host-disk-patrol.mjs b/scripts/check-host-disk-patrol.mjsnew file mode 100644index 0000000000..b2a4d62c76--- /dev/null+++ b/scripts/check-host-disk-patrol.mjs@@ -0,0 +1,120 @@+// Admission/UI contract proof with a production-emitted disk alert.+// GET estate/session data is synthetic. Patrol POSTs use the current Go handler+// from TestPatrolHostDiskBrowserBackend. No inference or infrastructure writes.+import { chromium, expect } from '../tests/integration/node_modules/@playwright/test/index.mjs';+import { mkdir, writeFile, readFile } from 'node:fs/promises';+import { createHash } from 'node:crypto';++const base = process.env.PLAYWRIGHT_BASE_URL;+const backend = process.env.PULSE_HOST_DISK_BROWSER_URL;+if (!base || !backend) throw new Error('Set PLAYWRIGHT_BASE_URL and PULSE_HOST_DISK_BROWSER_URL to isolated loopback servers');+for (const url of [base, backend]) {+ if (new URL(url).hostname !== '127.0.0.1') throw new Error('Proof servers must use loopback');+}+const output = new URL('../tmp/host-disk-patrol/', import.meta.url);+await mkdir(output, { recursive: true });+const browser = await chromium.launch({ headless: true });+const results = [];+const errors = [];+const diagnostics = [];+let lastPage;+try {+ const request = await browser.newContext();+ const alert = await (await request.request.get(`${backend}/proof/alert`)).json();+ await request.close();+ expect(alert.resourceId).toBe('agent:repro-host-source-01/disk:docker-data');+ expect(alert.value).toBe(85);+ expect(alert.threshold).toBe(85);+ for (const width of [1440, 390]) {+ const context = await browser.newContext({ viewport: { width, height: 1000 } });+ const page = await context.newPage();+ lastPage = page;+ page.on('pageerror', (error) => errors.push(error.message));+ page.on('console', (message) => {+ if (message.type() === 'error') diagnostics.push(message.text());+ });+ page.on('requestfailed', (request) => diagnostics.push(`${request.url()}: ${request.failure()?.errorText}`));+ let mode = 'accepted';+ const admissions = [];+ const state = { nodes: [], vms: [], containers: [], dockerHosts: [], hosts: [], storage: [], resources: [], activeAlerts: [alert], recentlyResolved: [], connectionHealth: {}, timestamp: Date.now() };+ await page.routeWebSocket('**/ws**', (socket) => socket.send(JSON.stringify({ type: 'initialState', data: state })));+ await page.route('**/api/**', async (route) => {+ const req = route.request();+ const path = new URL(req.url()).pathname;+ // Vite also serves source modules below /src/api/. Only stub HTTP API+ // endpoints; module requests must load the actual application source.+ if (!path.startsWith('/api/')) return route.continue();+ if (path === '/api/ai/patrol/run' && req.method() === 'POST') {+ const body = req.postDataJSON();+ expect(body).toEqual({ resource_ids: [alert.resourceId], alert_identifier: alert.id, alert_type: 'disk' });+ const response = await route.fetch({ url: `${backend}${path}?case=${mode}` });+ admissions.push({ mode, body, status: response.status(), response: await response.json() });+ return route.fulfill({ response });+ }+ if (req.method() !== 'GET') return route.fulfill({ status: 403, json: { error: 'Other writes disabled in proof' } });+ if (path === '/api/version') return route.fulfill({ json: { version: '6.5.0', build: 'proof', runtime: 'development', isDocker: false, isSourceBuild: true, isDevelopment: true } });+ if (path === '/api/updates/check') return route.fulfill({ json: { available: false, currentVersion: '6.5.0', latestVersion: '6.5.0', releaseNotes: '', downloadUrl: '', isPrerelease: false, isMajorUpgrade: false } });+ if (path === '/api/updates/status') return route.fulfill({ json: { status: 'idle', progress: 0, message: '', updatedAt: new Date().toISOString() } });+ if (path === '/api/security/status') return route.fulfill({ json: { hasAuthentication: true, hasProxyAuth: true, proxyAuthUsername: 'proof-operator', sessionCapabilities: { assistantEnabled: true, settingsRead: true, settingsWrite: true } } });+ if (path === '/api/license/runtime-capabilities') return route.fulfill({ json: { capabilities: ['ai_patrol', 'sso'], limits: [], blocked_capabilities: [], hosted_mode: false } });+ if (path === '/api/orgs') return route.fulfill({ json: [{ id: 'default', displayName: 'Proof' }] });+ if (path === '/api/resources') return route.fulfill({ json: { data: [], aggregations: { platformAdmission: { proxmox: false, docker: false, kubernetes: false, truenas: false, vmware: false, standalone: true } } } });+ if (path === '/api/state') return route.fulfill({ json: state });+ if (path === '/api/alerts/active') return route.fulfill({ json: [alert] });+ if (path === '/api/alerts/config') return route.fulfill({ json: { enabled: true, activationState: 'active', nodeDefaults: {}, guestDefaults: {}, agentDefaults: {}, overrides: {}, timeThresholds: {}, notifications: {} } });+ if (path === '/api/ai/settings') return route.fulfill({ json: { enabled: true, model: 'fixture:admission', control_level: 'read_only' } });+ if (/\/(history|events|delivery-diagnosis|sessions|models|findings|incidents)$/.test(path)) return route.fulfill({ json: [] });+ return route.fulfill({ json: {} });+ });+ await page.goto(`${base}/alerts`, { waitUntil: 'domcontentloaded' });+ const button = page.getByTitle('Have Patrol investigate this alert', { exact: true });+ await expect(button).toBeVisible({ timeout: 30000 });+ await button.scrollIntoViewIfNeeded();+ const rect = await button.boundingBox();+ expect(rect.x).toBeGreaterThanOrEqual(0);+ expect(rect.x + rect.width).toBeLessThanOrEqual(width);+ await page.screenshot({ path: new URL(`default-${width}.png`, output).pathname, fullPage: true });+ const menu = page.getByRole('button', { name: 'More alert actions', exact: true });+ await menu.click();+ await page.screenshot({ path: new URL(`menu-${width}.png`, output).pathname, fullPage: true });+ await page.keyboard.press('Escape');+ await expect(menu).toHaveAttribute('aria-expanded', 'false');+ await menu.click();+ await page.getByText('Active Alerts', { exact: true }).first().click();+ await expect(menu).toHaveAttribute('aria-expanded', 'false');+ for (const [scenario, status, text] of [+ ['accepted', 200, `Patrol is investigating ${alert.resourceName}`],+ ['busy', 409, 'Patrol is already running.'],+ ['unresolved', 422, 'One or more requested resource identities could not be resolved exactly'],+ ]) {+ mode = scenario;+ const before = admissions.length;+ await button.focus();+ await page.keyboard.press('Enter');+ await expect.poll(() => admissions.length).toBe(before + 1);+ expect(admissions.at(-1).status).toBe(status);+ await expect(page.getByText(text, { exact: false }).first()).toBeVisible();+ await page.screenshot({ path: new URL(`${scenario}-${width}.png`, output).pathname, fullPage: true });+ }+ mode = 'accepted';+ await page.reload({ waitUntil: 'domcontentloaded' });+ await expect(button).toBeVisible();+ await button.click();+ await expect.poll(() => admissions.at(-1).mode).toBe('accepted');+ await expect(page.getByText(`Patrol is investigating ${alert.resourceName}`, { exact: true })).toBeVisible();+ results.push({ width, admissions });+ await context.close();+ }+ expect(errors).toEqual([]);+ const paths = ['internal/unifiedresources/history_identity.go', 'internal/ai/patrol_alert_scope.go', 'internal/ai/patrol_state.go', 'internal/ai/patrol_run.go', 'internal/ai/patrol_ai.go', 'internal/ai/patrol_triggers.go'];+ const content_sha256 = Object.fromEntries(await Promise.all(paths.map(async (path) => [path, createHash('sha256').update(await readFile(new URL(`../${path}`, import.meta.url))).digest('hex')])));+ await writeFile(new URL('result.json', output), JSON.stringify({ result: 'passed', verified_at: new Date().toISOString(), frontend_base_sha: process.env.PROOF_BASE_SHA, content_sha256, routes: ['/alerts'], viewports: [1440, 390], states: ['default', 'menu open/closed', 'accepted', 'busy', 'unresolved owner', 'reload'], interactions: ['pointer', 'Enter', 'Escape', 'outside click', 'reload then re-submit'], results, errors, limits: 'Real API admission, synthetic estate/session, no inference or diagnosis qualification' }, null, 2));+} catch (error) {+ if (lastPage && !lastPage.isClosed()) {+ await lastPage.screenshot({ path: new URL('failure.png', output).pathname, fullPage: true });+ await writeFile(new URL('failure.txt', output), `${error.stack}\nPage errors: ${JSON.stringify(errors)}\nDiagnostics: ${JSON.stringify(diagnostics)}\nURL: ${lastPage.url()}\n${await lastPage.locator('body').innerText()}`);+ }+ throw error;+} finally {+ await browser.close();+}