fix: distinguish null from zero for all measurement fields

Drop COALESCE-to-zero on REAL columns across all SQL queries so NULL
(unmeasured) propagates through as *float64 nil in Go. Rendering shows
"—" for nil, actual value for measured zero.

- Remove HasVolumes from PIIPolicy/WastePolicy (nil pointer is the signal)
- Make all float fields on AccountSummary, ServiceStatus, PolicyCategoryStatus,
  WastePolicy, PIIPolicy nullable (*float64)
- Adapt waste detail columns based on category benefit type (volume_reduction
  shows Volume+Bytes, bytes-only shows just Bytes)

Author: binarylogic

internal/app/chat/chat.go

@@ -529,14 +529,16 @@ func (m *Model) emptyStateContent() string {
 
 // wastePercent computes waste % preferring bytes.
 func wastePercent(s domain.AccountSummary) int {
-	if s.TotalBytesPerHour > 0 && s.EstimatedBytesPerHour > 0 {
-		return int(math.Round(s.EstimatedBytesPerHour / s.TotalBytesPerHour * 100))
+	if s.TotalBytesPerHour != nil && *s.TotalBytesPerHour > 0 &&
+		s.EstimatedBytesPerHour != nil && *s.EstimatedBytesPerHour > 0 {
+		return int(math.Round(*s.EstimatedBytesPerHour / *s.TotalBytesPerHour * 100))
 	}
 	if s.EstimatedCostPerHour != nil && s.TotalCostPerHour != nil && *s.TotalCostPerHour > 0 {
 		return int(math.Round(*s.EstimatedCostPerHour / *s.TotalCostPerHour * 100))
 	}
-	if s.TotalVolumePerHour > 0 && s.EstimatedVolumePerHour > 0 {
-		return int(math.Round(s.EstimatedVolumePerHour / s.TotalVolumePerHour * 100))
+	if s.TotalVolumePerHour != nil && *s.TotalVolumePerHour > 0 &&
+		s.EstimatedVolumePerHour != nil && *s.EstimatedVolumePerHour > 0 {
+		return int(math.Round(*s.EstimatedVolumePerHour / *s.TotalVolumePerHour * 100))
 	}
 	return 0
 }

internal/app/statusbar/pii/pii.go

@@ -114,12 +114,12 @@ func (m *Model) Update(msg tea.Msg) tea.Cmd {
 // stateKey builds a string key for change detection.
 func (m *Model) stateKey(summary domain.AccountSummary, policies []domain.PIIPolicy, fixedCount int64) string {
 	var b strings.Builder
-	fmt.Fprintf(&b, "%.0f:%.0f:%d:%d",
-		ptrVal(summary.TotalServiceVolumePerHour), summary.TotalVolumePerHour,
+	fmt.Fprintf(&b, "%v:%v:%d:%d",
+		summary.TotalServiceVolumePerHour, summary.TotalVolumePerHour,
 		len(policies), fixedCount)
 	for _, p := range policies {
-		fmt.Fprintf(&b, "|%s:%s:%d:%.0f:%v:%v",
-			p.ServiceName, p.LogEventName, len(p.Fields), p.VolumePerHour, p.AnyObserved, p.HasVolumes)
+		fmt.Fprintf(&b, "|%s:%s:%d:%v:%v",
+			p.ServiceName, p.LogEventName, len(p.Fields), p.VolumePerHour, p.AnyObserved)
 		for _, f := range p.Fields {
 			fmt.Fprintf(&b, ":%v", f.Observed)
 			for _, t := range f.PIITypes {
@@ -245,8 +245,8 @@ func (m *Model) renderTable(width int) string {
 
 	for _, p := range m.policies {
 		vol := "—"
-		if p.HasVolumes {
-			vol = format.Volume(p.VolumePerHour) + " evt/hr"
+		if p.VolumePerHour != nil {
+			vol = format.Volume(*p.VolumePerHour) + " evt/hr"
 		}
 		tbl.Row(
 			p.LogEventName,
@@ -348,16 +348,12 @@ func summaryDiscoveryPercent(s domain.AccountSummary) int {
 	if s.TotalServiceVolumePerHour == nil || *s.TotalServiceVolumePerHour <= 0 {
 		return 100
 	}
-	pct := int(math.Round(s.TotalVolumePerHour / *s.TotalServiceVolumePerHour * 100))
+	if s.TotalVolumePerHour == nil {
+		return 0
+	}
+	pct := int(math.Round(*s.TotalVolumePerHour / *s.TotalServiceVolumePerHour * 100))
 	if pct > 100 {
 		pct = 100
 	}
 	return pct
 }
-
-func ptrVal(p *float64) float64 {
-	if p == nil {
-		return 0
-	}
-	return *p
-}

internal/app/statusbar/services/services.go

@@ -108,16 +108,16 @@ func (m *Model) Update(msg tea.Msg) tea.Cmd {
 
 // stateKey builds a string key for change detection.
 func (m *Model) stateKey(s domain.AccountSummary, services []domain.ServiceStatus) string {
-	key := fmt.Sprintf("%v:%d:%d:%d:%d:%d:%d:%d:%d:%s:%s:%s:%.0f:%.0f:%d",
+	key := fmt.Sprintf("%v:%d:%d:%d:%d:%d:%d:%d:%d:%s:%s:%s:%v:%v:%d",
 		s.ReadyForUse, s.ServiceCount, s.ActiveServices,
 		s.EventCount, s.AnalyzedCount, s.OkServices,
 		s.ErrorServices, s.StaleServices, s.QuarantinedCount,
 		s.Health, s.Error, s.Warning,
-		ptrVal(s.TotalServiceVolumePerHour), s.TotalVolumePerHour,
+		s.TotalServiceVolumePerHour, s.TotalVolumePerHour,
 		len(services))
 
 	for _, svc := range services {
-		key += fmt.Sprintf("|%s:%s:%s:%d:%d:%.0f:%.0f:%.2f",
+		key += fmt.Sprintf("|%s:%s:%s:%d:%d:%v:%v:%v",
 			svc.Name, svc.Health, svc.Warning, svc.LogEventCount, svc.LogEventAnalyzedCount,
 			svc.ServiceVolumePerHour, svc.LogEventVolumePerHour, svc.ServiceCostPerHourVolumeUSD)
 	}
@@ -199,8 +199,8 @@ func (m *Model) renderSummary() string {
 	}
 
 	// Total volume.
-	if s.TotalVolumePerHour > 0 {
-		parts = append(parts, format.Volume(s.TotalVolumePerHour)+" evt/hr")
+	if s.TotalVolumePerHour != nil && *s.TotalVolumePerHour > 0 {
+		parts = append(parts, format.Volume(*s.TotalVolumePerHour)+" evt/hr")
 	}
 
 	// Total cost from account summary (pre-aggregated by control plane).
@@ -238,11 +238,19 @@ func (m *Model) renderServiceTable(width, maxRows int) string {
 
 	bar := m.discoveryBar()
 	for _, svc := range visible {
+		vol := "—"
+		if svc.ServiceVolumePerHour != nil {
+			vol = format.Volume(*svc.ServiceVolumePerHour) + "/hr"
+		}
+		cost := "—"
+		if svc.ServiceCostPerHourVolumeUSD != nil {
+			cost = format.YearlyCost(*svc.ServiceCostPerHourVolumeUSD)
+		}
 		tbl.Row(
 			m.renderServiceName(svc),
 			m.renderLogEvents(svc, bar),
-			format.Volume(svc.ServiceVolumePerHour)+"/hr",
-			format.YearlyCost(svc.ServiceCostPerHourVolumeUSD),
+			vol,
+			cost,
 		)
 	}
 
@@ -294,7 +302,7 @@ func (m *Model) discoveryBar() progress.Model {
 // never exactly 100% due to throughput fluctuations).
 func (m *Model) renderLogEvents(svc domain.ServiceStatus, bar progress.Model) string {
 	count := fmt.Sprintf("%-5d", svc.LogEventCount)
-	if svc.ServiceVolumePerHour <= 0 {
+	if svc.ServiceVolumePerHour == nil || *svc.ServiceVolumePerHour <= 0 {
 		return count
 	}
 	pct := discoveryPercent(svc)
@@ -310,7 +318,10 @@ func summaryDiscoveryPercent(s domain.AccountSummary) int {
 	if s.TotalServiceVolumePerHour == nil || *s.TotalServiceVolumePerHour <= 0 {
 		return 100
 	}
-	pct := int(math.Round(s.TotalVolumePerHour / *s.TotalServiceVolumePerHour * 100))
+	if s.TotalVolumePerHour == nil {
+		return 0
+	}
+	pct := int(math.Round(*s.TotalVolumePerHour / *s.TotalServiceVolumePerHour * 100))
 	if pct > 100 {
 		pct = 100
 	}
@@ -319,19 +330,15 @@ func summaryDiscoveryPercent(s domain.AccountSummary) int {
 
 // discoveryPercent computes how much of a service's volume has been classified.
 func discoveryPercent(svc domain.ServiceStatus) int {
-	if svc.ServiceVolumePerHour <= 0 {
+	if svc.ServiceVolumePerHour == nil || *svc.ServiceVolumePerHour <= 0 {
 		return 100
 	}
-	pct := int(math.Round(svc.LogEventVolumePerHour / svc.ServiceVolumePerHour * 100))
+	if svc.LogEventVolumePerHour == nil {
+		return 0
+	}
+	pct := int(math.Round(*svc.LogEventVolumePerHour / *svc.ServiceVolumePerHour * 100))
 	if pct > 100 {
 		pct = 100
 	}
 	return pct
 }
-
-func ptrVal(p *float64) float64 {
-	if p == nil {
-		return 0
-	}
-	return *p
-}

internal/app/statusbar/waste/detail.go

@@ -62,8 +62,8 @@ func (d *detail) renderHeader() string {
 		parts = append(parts, warn.Render("●")+" "+warn.Render(fmt.Sprintf("%d pending", d.category.PendingCount)))
 	}
 
-	if d.category.EstimatedCostPerHour > 0 {
-		parts = append(parts, muted.Render("~"+format.YearlyCost(d.category.EstimatedCostPerHour)))
+	if d.category.EstimatedCostPerHour != nil && *d.category.EstimatedCostPerHour > 0 {
+		parts = append(parts, muted.Render("~"+format.YearlyCost(*d.category.EstimatedCostPerHour)))
 	}
 
 	return strings.Join(parts, sep)
@@ -72,38 +72,45 @@ func (d *detail) renderHeader() string {
 // renderTable renders the per-policy table.
 func (d *detail) renderTable(width int) string {
 	tbl := table.New(d.theme, table.WithMaxValueWidth(30))
-	tbl.Headers("Log Event", "Service", "Volume", "Est. Savings")
+
+	showVolume := d.category.ReducesVolume()
+	if showVolume {
+		tbl.Headers("Log Event", "Service", "Volume", "Bytes", "Est. Savings")
+	} else {
+		tbl.Headers("Log Event", "Service", "Bytes", "Est. Savings")
+	}
 	tbl.SetWidth(width)
 
 	dot := lipgloss.NewStyle().Foreground(d.theme.Warning).Background(d.theme.Bg).Render("●")
 
 	for _, p := range d.policies {
-		vol := "—"
-		if p.HasVolumes {
-			vol = format.Volume(p.VolumePerHour) + " evt/hr"
+		bytes := "—"
+		if p.BytesPerHour != nil {
+			bytes = format.Bytes(*p.BytesPerHour) + "/hr"
 		}
-		savings := "—"
-		if p.HasVolumes {
-			savings = formatPolicyCost(p)
+		savings := formatPolicyCost(p)
+
+		if showVolume {
+			vol := "—"
+			if p.VolumePerHour != nil {
+				vol = format.Volume(*p.VolumePerHour) + " evt/hr"
+			}
+			tbl.Row(dot+" "+p.LogEventName, p.ServiceName, vol, bytes, savings)
+		} else {
+			tbl.Row(dot+" "+p.LogEventName, p.ServiceName, bytes, savings)
 		}
-		tbl.Row(
-			dot+" "+p.LogEventName,
-			p.ServiceName,
-			vol,
-			savings,
-		)
 	}
 
 	return tbl.View()
 }
 
 // formatPolicyCost returns the estimated yearly cost for a single policy.
 func formatPolicyCost(p domain.WastePolicy) string {
-	if p.EstimatedCostPerHour > 0 {
-		yearly := p.EstimatedCostPerHour * 8760
+	if p.EstimatedCostPerHour != nil && *p.EstimatedCostPerHour > 0 {
+		yearly := *p.EstimatedCostPerHour * 8760
 		if yearly >= 1 {
 			return "~" + format.Cost(yearly) + "/yr"
 		}
 	}
-	return "-"
+	return "—"
 }

internal/app/statusbar/waste/waste.go

@@ -118,20 +118,18 @@ func (m *Model) Update(msg tea.Msg) tea.Cmd {
 
 // stateKey builds a string key for change detection.
 func (m *Model) stateKey(s domain.AccountSummary, cats []domain.PolicyCategoryStatus) string {
-	key := fmt.Sprintf("%v:%d:%d:%d:%d:%d:%v:%v:%v:%.0f:%.0f:%v:%v:%.0f:%.0f:%v:%.0f:%.0f:%d",
+	key := fmt.Sprintf("%v:%d:%d:%d:%d:%d:%v:%v:%v:%v:%v:%v:%v:%v:%v:%v:%v:%v:%d",
 		s.ReadyForUse, s.EventCount, s.AnalyzedCount, s.PendingPolicyCount,
 		s.ApprovedPolicyCount, s.DismissedPolicyCount,
-		ptrVal(s.EstimatedCostPerHour),
-		ptrVal(s.EstimatedCostPerHourBytes),
-		ptrVal(s.EstimatedCostPerHourVolume),
+		s.EstimatedCostPerHour, s.EstimatedCostPerHourBytes, s.EstimatedCostPerHourVolume,
 		s.EstimatedVolumePerHour, s.EstimatedBytesPerHour,
-		ptrVal(s.ObservedCostBefore), ptrVal(s.ObservedCostAfter),
+		s.ObservedCostBefore, s.ObservedCostAfter,
 		s.ObservedVolumeBefore, s.ObservedVolumeAfter,
-		ptrVal(s.TotalCostPerHour), s.TotalVolumePerHour,
+		s.TotalCostPerHour, s.TotalVolumePerHour,
 		s.TotalBytesPerHour, len(cats))
 
 	for _, c := range cats {
-		key += fmt.Sprintf("|%s:%d:%d:%d:%.0f:%.0f:%.2f:%.0f:%.0f:%.0f:%.0f:%.2f:%.2f:%d:%d",
+		key += fmt.Sprintf("|%s:%d:%d:%d:%v:%v:%v:%v:%v:%v:%v:%v:%v:%d:%d",
 			c.Category, c.PendingCount, c.ApprovedCount, c.DismissedCount,
 			c.EstimatedVolumePerHour, c.EstimatedBytesPerHour, c.EstimatedCostPerHour,
 			c.ObservedVolumeBefore, c.ObservedVolumeAfter,
@@ -245,8 +243,9 @@ func (m *Model) CompactView() string {
 
 // wastePercent computes the estimated waste as a percentage of total bytes.
 func wastePercent(s domain.AccountSummary) int {
-	if s.TotalBytesPerHour > 0 && s.EstimatedBytesPerHour > 0 {
-		return int(math.Round(s.EstimatedBytesPerHour / s.TotalBytesPerHour * 100))
+	if s.TotalBytesPerHour != nil && *s.TotalBytesPerHour > 0 &&
+		s.EstimatedBytesPerHour != nil && *s.EstimatedBytesPerHour > 0 {
+		return int(math.Round(*s.EstimatedBytesPerHour / *s.TotalBytesPerHour * 100))
 	}
 	return 0
 }
@@ -384,8 +383,8 @@ func (m *Model) discoveryBar() progress.Model {
 
 // formatCategoryCost returns estimated yearly cost for a category.
 func formatCategoryCost(c domain.PolicyCategoryStatus) string {
-	if c.EstimatedCostPerHour > 0 {
-		yearly := c.EstimatedCostPerHour * 8760
+	if c.EstimatedCostPerHour != nil && *c.EstimatedCostPerHour > 0 {
+		yearly := *c.EstimatedCostPerHour * 8760
 		if yearly >= 1 {
 			return "~" + format.Cost(yearly) + "/yr"
 		}
@@ -395,11 +394,13 @@ func formatCategoryCost(c domain.PolicyCategoryStatus) string {
 
 // formatObservedCost returns the observed cost reduction for a category.
 func formatObservedCost(c domain.PolicyCategoryStatus) string {
-	diff := c.ObservedCostBefore - c.ObservedCostAfter
-	if diff > 0 {
-		yearly := diff * 8760
-		if yearly >= 1 {
-			return "-" + format.Cost(yearly) + "/yr"
+	if c.ObservedCostBefore != nil && c.ObservedCostAfter != nil {
+		diff := *c.ObservedCostBefore - *c.ObservedCostAfter
+		if diff > 0 {
+			yearly := diff * 8760
+			if yearly >= 1 {
+				return "-" + format.Cost(yearly) + "/yr"
+			}
 		}
 	}
 	return "—"
@@ -414,16 +415,11 @@ func formatObservedSaving(s domain.AccountSummary) string {
 		}
 		return ""
 	}
-	diff := s.ObservedVolumeBefore - s.ObservedVolumeAfter
-	if diff > 0 {
-		return format.Volume(diff) + " evt/hr"
+	if s.ObservedVolumeBefore != nil && s.ObservedVolumeAfter != nil {
+		diff := *s.ObservedVolumeBefore - *s.ObservedVolumeAfter
+		if diff > 0 {
+			return format.Volume(diff) + " evt/hr"
+		}
 	}
 	return ""
 }
-
-func ptrVal(p *float64) float64 {
-	if p == nil {
-		return 0
-	}
-	return *p
-}

internal/domain/account_summary.go

@@ -46,25 +46,25 @@ type AccountSummary struct {
 	TotalServiceVolumePerHour *float64
 	TotalServiceCostPerHour   *float64
 
-	// Log event throughput (discovered events).
-	TotalCostPerHour       *float64 // nil when pricing unavailable
+	// Log event throughput (discovered events). Nil when unmeasured.
+	TotalCostPerHour       *float64
 	TotalCostPerHourBytes  *float64
 	TotalCostPerHourVolume *float64
-	TotalVolumePerHour     float64
-	TotalBytesPerHour      float64
+	TotalVolumePerHour     *float64
+	TotalBytesPerHour      *float64
 
-	// Estimated savings from pending policies.
-	EstimatedCostPerHour       *float64 // nil when pricing unavailable
+	// Estimated savings from pending policies. Nil when unmeasured.
+	EstimatedCostPerHour       *float64
 	EstimatedCostPerHourBytes  *float64
 	EstimatedCostPerHourVolume *float64
-	EstimatedVolumePerHour     float64
-	EstimatedBytesPerHour      float64
+	EstimatedVolumePerHour     *float64
+	EstimatedBytesPerHour      *float64
 
-	// Observed impact from approved policies (before/after).
-	ObservedCostBefore   *float64 // nil when pricing unavailable
+	// Observed impact from approved policies (before/after). Nil when unmeasured.
+	ObservedCostBefore   *float64
 	ObservedCostAfter    *float64
-	ObservedVolumeBefore float64
-	ObservedVolumeAfter  float64
-	ObservedBytesBefore  float64
-	ObservedBytesAfter   float64
+	ObservedVolumeBefore *float64
+	ObservedVolumeAfter  *float64
+	ObservedBytesBefore  *float64
+	ObservedBytesAfter   *float64
 }