fix(security): FR-014 verdict purity on the report page — share the tier-driven verdict with the report payload

Codex review follow-up. The server-list summary (GetScanSummary) derived
the verdict tier-driven/baseline-only (FR-014), but the report page badge
still read the RAW threat-level ReportSummary — with deep scan on, a
tierless Docker-scanner finding classified "dangerous" made the report say
dangerous while the server list said clean, and the same finding counted
as Warning on one surface and Dangerous on the other.

- extract deriveBaselineVerdict() as the single source of truth, shared by
  GetScanSummary and AggregateReports so the two surfaces structurally
  cannot disagree
- AggregatedReport gains Verdict + tier-driven FindingCounts (additive;
  raw Summary counts retained for transparency)
- ScanReport.vue: status badge, threat tiles, Quarantine-button gate and
  the Approve-disable gate (hasUnresolvedCritical) now read the
  tier-driven verdict/finding_counts (raw summary only as a fallback for
  pre-Spec-077 payloads); the approve gate now mirrors the backend
  hard-tier-only isBlockingFinding instead of raw summary.critical
- ServerDetail.vue: approve-confirmation count and the Security-tab
  summary strip prefer tier-driven finding_counts over the raw report
  summary, so a tierless deep-scan "dangerous" finding no longer triggers
  the "Dangerous Findings Detected" modal on a clean baseline
- frontend/src/types/api.ts: SecurityScanSummary catches up with the wire
  contract (deep_scan, scanners_run/failed/total); SecurityScanReport
  gains verdict + finding_counts

Tests: engine-level AggregateReports verdict matrix (tierless-dangerous →
clean/warning-bucket, hard → dangerous, soft → warnings) and an
end-to-end pin that GetScanReportByJobID.Verdict/FindingCounts equal
GetScanSummary for the same scan data.

Assumption documented (zero-interruption policy): ServerCard.vue was
reported as sharing the raw-summary preference but already reads only the
tier-driven security_scan.finding_counts — left unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Dumbris

frontend/src/types/api.ts

@@ -42,6 +42,15 @@ export interface SecurityScanSummary {
   risk_score: number
   status: SecurityScanStatus
   finding_counts?: SecurityScanFindingCounts
+  // Scanner coverage for the primary (baseline) scan pass — informational only.
+  // Spec 077 US3 (FR-008/FR-014): status derives SOLELY from baseline findings;
+  // a failed Docker deep scanner never downgrades the verdict.
+  scanners_run?: number
+  scanners_failed?: number
+  scanners_total?: number
+  // Opt-in deep-scan layer status (Spec 077 US3), always emitted on a computed
+  // summary (enabled=false when off). Informational — never influences status.
+  deep_scan?: DeepScanDescriptor
 }
 
 // Security scan finding (Spec 039)
@@ -74,7 +83,14 @@ export interface SecurityScanReport {
   status: SecurityScanStatus
   risk_score: number
   findings: SecurityScanFinding[]
-  finding_counts: SecurityScanFindingCounts
+  // Tier-driven, baseline-only verdict (Spec 077 FR-014): 'dangerous' only for
+  // hard-tier baseline findings; tierless deep-scan/external findings never
+  // move it. Verdict-bearing UI must read this, NOT summary (raw counts).
+  verdict?: 'clean' | 'warnings' | 'dangerous'
+  // Tier-driven buckets matching SecurityScanSummary.finding_counts (a tierless
+  // 'dangerous' finding buckets as warning — informs, never gates).
+  finding_counts?: SecurityScanFindingCounts
+  // Raw threat-level/severity counts across ALL findings — transparency only.
   summary: SecurityScanReportSummary
   scanned_at: string
   duration_ms?: number

frontend/src/views/ScanReport.vue

@@ -96,25 +96,25 @@
         <div class="stats shadow bg-base-100">
           <div class="stat py-3 px-4">
             <div class="stat-title text-xs">Dangerous</div>
-            <div class="stat-value text-lg text-error">{{ report.summary?.dangerous ?? 0 }}</div>
+            <div class="stat-value text-lg text-error">{{ threatCounts.dangerous }}</div>
           </div>
         </div>
         <div class="stats shadow bg-base-100">
           <div class="stat py-3 px-4">
             <div class="stat-title text-xs">Warnings</div>
-            <div class="stat-value text-lg text-warning">{{ report.summary?.warnings ?? 0 }}</div>
+            <div class="stat-value text-lg text-warning">{{ threatCounts.warnings }}</div>
           </div>
         </div>
         <div class="stats shadow bg-base-100">
           <div class="stat py-3 px-4">
             <div class="stat-title text-xs">Info</div>
-            <div class="stat-value text-lg text-info">{{ report.summary?.info_level ?? 0 }}</div>
+            <div class="stat-value text-lg text-info">{{ threatCounts.info }}</div>
           </div>
         </div>
         <div class="stats shadow bg-base-100">
           <div class="stat py-3 px-4">
             <div class="stat-title text-xs">Total</div>
-            <div class="stat-value text-lg">{{ report.summary?.total ?? 0 }}</div>
+            <div class="stat-value text-lg">{{ threatCounts.total }}</div>
           </div>
         </div>
       </div>
@@ -555,7 +555,7 @@
             </div>
             <div class="flex gap-2">
               <button
-                v-if="serverAdminState === 'enabled' && report.summary?.dangerous > 0"
+                v-if="serverAdminState === 'enabled' && reportStatus === 'dangerous'"
                 @click="quarantineServer"
                 :disabled="actionLoading"
                 class="btn btn-error btn-sm"
@@ -638,17 +638,41 @@ const scanContext = computed(() => {
   return report.value?.scan_context || null
 })
 
-// Status display
+// Status display. Spec 077 FR-014 verdict purity: the badge shows the
+// tier-driven, baseline-only `verdict` computed server-side with the SAME
+// predicate as the server-list status, so this page can never say "dangerous"
+// while the server list says "clean" (a tierless deep-scan/external finding
+// never moves the verdict). Raw summary counts remain only as a fallback for
+// reports served by a core that predates the verdict field.
 const reportStatus = computed(() => {
   if (!report.value) return 'unknown'
   if (report.value.scan_complete === false) return 'incomplete'
   if (report.value.empty_scan) return 'empty'
   if (!report.value.findings || report.value.findings.length === 0) return 'clean'
+  if (report.value.verdict) return report.value.verdict
   if (report.value.summary?.dangerous > 0) return 'dangerous'
   if (report.value.summary?.warnings > 0) return 'warnings'
   return 'clean'
 })
 
+// Threat tiles use the tier-driven buckets (finding_counts) matching the
+// server list exactly (Spec 077 FR-014): a tierless deep-scan "dangerous"
+// finding counts as a warning on BOTH surfaces. Falls back to the raw
+// threat-level summary for pre-Spec-077 payloads.
+const threatCounts = computed(() => {
+  const r = report.value
+  const fc = r?.finding_counts
+  if (fc) {
+    return { dangerous: fc.dangerous ?? 0, warnings: fc.warning ?? 0, info: fc.info ?? 0, total: fc.total ?? 0 }
+  }
+  return {
+    dangerous: r?.summary?.dangerous ?? 0,
+    warnings: r?.summary?.warnings ?? 0,
+    info: r?.summary?.info_level ?? 0,
+    total: r?.summary?.total ?? 0,
+  }
+})
+
 const statusBadgeClass = computed(() => {
   switch (reportStatus.value) {
     case 'dangerous': return 'badge-error'
@@ -800,8 +824,15 @@ async function quarantineServer() {
 
 // F-04: Go through the security-aware approval path instead of the legacy
 // unquarantine endpoint. hasUnresolvedCritical disables the primary Approve
-// button so the user must use Force Approve explicitly.
+// button so the user must use Force Approve explicitly. It mirrors the
+// backend approval gate (Spec 077 FR-021: hard-tier BASELINE findings only)
+// via the tier-driven finding_counts — a tierless deep-scan/external finding
+// or a non-blocking soft finding with "critical" severity must not lock the
+// Approve button when the backend would accept. Raw summary.critical is only
+// a fallback for payloads that predate finding_counts.
 const hasUnresolvedCritical = computed(() => {
+  const fc = report.value?.finding_counts
+  if (fc) return (fc.dangerous ?? 0) > 0
   return (report.value?.summary?.critical ?? 0) > 0
 })
 

frontend/src/views/ServerDetail.vue

@@ -1230,10 +1230,10 @@
                   <div class="text-xs text-base-content/50">Risk Score</div>
                 </div>
                 <div class="flex gap-4 text-sm">
-                  <span v-if="scanReport.summary?.dangerous" class="text-error font-semibold">{{ scanReport.summary.dangerous }} dangerous</span>
-                  <span v-if="scanReport.summary?.warnings" class="text-warning font-semibold">{{ scanReport.summary.warnings }} warnings</span>
-                  <span v-if="scanReport.summary?.info_level" class="text-info">{{ scanReport.summary.info_level }} info</span>
-                  <span v-if="scanReport.summary?.total === 0" class="text-success font-semibold">No findings</span>
+                  <span v-if="scanThreatCounts.dangerous" class="text-error font-semibold">{{ scanThreatCounts.dangerous }} dangerous</span>
+                  <span v-if="scanThreatCounts.warnings" class="text-warning font-semibold">{{ scanThreatCounts.warnings }} warnings</span>
+                  <span v-if="scanThreatCounts.info" class="text-info">{{ scanThreatCounts.info }} info</span>
+                  <span v-if="scanThreatCounts.total === 0" class="text-success font-semibold">No findings</span>
                 </div>
               </div>
 
@@ -2401,19 +2401,40 @@ const approveDialogMode = ref<'no_scan' | 'critical'>('no_scan')
 
 // Spec 077 FR-021: the approval gate blocks on baseline DANGEROUS findings only
 // (hard-tier). Deep-scan findings inform but never gate. The server-side verdict
-// is now tier-driven, so the modal mirrors it by counting `dangerous` (threat
-// level) rather than `critical` (severity) — a soft finding can be "high"
-// severity yet must not block approval.
+// is tier-driven, so the modal mirrors it via the TIER-DRIVEN finding_counts —
+// NOT the raw threat-level report summary, where a tierless deep-scan/external
+// finding can read "dangerous" and would show the "Dangerous Findings Detected"
+// dialog even though the backend gate (hard-tier only) would not block.
 const dangerousFindingCount = computed(() => {
-  // Prefer the loaded scan report summary if available; otherwise fall back
-  // to finding_counts on the server's security_scan summary (if populated).
+  // Prefer the tier-driven counts on the loaded report, then the server's
+  // security_scan summary; the raw report summary is only a last-resort
+  // fallback for cores that predate report-level finding_counts.
   const rep = scanReport.value as any
-  if (rep?.summary?.dangerous != null) return rep.summary.dangerous as number
+  if (rep?.finding_counts?.dangerous != null) return rep.finding_counts.dangerous as number
   const scan = server.value?.security_scan as any
   if (scan?.finding_counts?.dangerous != null) return scan.finding_counts.dangerous as number
+  if (rep?.summary?.dangerous != null) return rep.summary.dangerous as number
   return 0
 })
 
+// Tier-driven counts for the Security-tab summary strip (Spec 077 FR-014):
+// buckets findings exactly like the server list's finding_counts — a tierless
+// deep-scan/external "dangerous" finding shows as a warning on both surfaces.
+// Raw threat-level summary is only a fallback for pre-Spec-077 payloads.
+const scanThreatCounts = computed(() => {
+  const rep = scanReport.value as any
+  const fc = rep?.finding_counts
+  if (fc) {
+    return { dangerous: fc.dangerous ?? 0, warnings: fc.warning ?? 0, info: fc.info ?? 0, total: fc.total ?? 0 }
+  }
+  return {
+    dangerous: rep?.summary?.dangerous ?? 0,
+    warnings: rep?.summary?.warnings ?? 0,
+    info: rep?.summary?.info_level ?? 0,
+    total: rep?.summary?.total ?? 0,
+  }
+})
+
 const hasCompletedScanForApprove = computed(() => {
   if (scanReport.value) return true
   return !!server.value?.security_scan?.last_scan_at

internal/security/scanner/engine.go

@@ -824,6 +824,16 @@ func AggregateReports(jobID, serverName string, reports []*ScanReport) *Aggregat
 	agg.RiskScore = CalculateRiskScore(agg.Findings)
 	agg.Summary = SummarizeFindings(agg.Findings)
 
+	// Spec 077 FR-014 verdict purity: the report-level verdict uses the SAME
+	// tier-driven, baseline-only derivation as the server-list summary
+	// (GetScanSummary via deriveBaselineVerdict), so the report page can never
+	// disagree with the server verdict — a tierless deep-scan/external
+	// "dangerous" finding never moves it. Summary above keeps the RAW
+	// threat-level counts for transparency; verdict-bearing UI reads these.
+	verdict, counts := deriveBaselineVerdict(agg.Findings)
+	agg.Verdict = verdict
+	agg.FindingCounts = &counts
+
 	// ScannersRun = number of successful reports
 	agg.ScannersRun = len(reports)
 	// ScanComplete = at least one scanner succeeded

internal/security/scanner/engine_test.go

@@ -1315,3 +1315,80 @@ func TestDeepScanFailureLeavesBaselineVerdictUnchanged(t *testing.T) {
 		t.Errorf("disabled deep scan must not report failures, got %+v", baseline.DeepScan.ScannersFailed)
 	}
 }
+
+// TestAggregateReportsVerdictBaselineOnly locks Spec 077 FR-014 at the
+// aggregated-report level (the payload the report PAGE renders): the
+// report-level Verdict/FindingCounts must use the SAME tier-driven,
+// baseline-only derivation as the server-list summary (GetScanSummary), so
+// the report page badge can never say "dangerous" while the server list says
+// "clean". Summary keeps the RAW threat-level counts for transparency; the
+// verdict is what verdict-bearing UI must read.
+func TestAggregateReportsVerdictBaselineOnly(t *testing.T) {
+	t.Run("tierless dangerous finding does not move the verdict", func(t *testing.T) {
+		// A deep-scan/external scanner finding carries no Tier. Rule id
+		// "tool-poisoning" makes ClassifyThreat assign threat_level=dangerous.
+		agg := AggregateReports("j1", "server-a", []*ScanReport{
+			{
+				ID: "r1", ScannerID: "trivy",
+				Findings: []ScanFinding{
+					{RuleID: "tool-poisoning", Severity: SeverityCritical, Title: "hidden instruction"},
+				},
+			},
+		})
+		if agg.Verdict != "clean" {
+			t.Errorf("verdict must derive solely from baseline findings (FR-014): expected 'clean', got %q", agg.Verdict)
+		}
+		if agg.FindingCounts == nil {
+			t.Fatal("expected FindingCounts on aggregated report")
+		}
+		if agg.FindingCounts.Dangerous != 0 {
+			t.Errorf("tierless findings must never count as dangerous, got %d", agg.FindingCounts.Dangerous)
+		}
+		if agg.FindingCounts.Warning != 1 {
+			t.Errorf("tierless dangerous finding must surface at warning prominence, got Warning=%d Info=%d",
+				agg.FindingCounts.Warning, agg.FindingCounts.Info)
+		}
+		// Raw threat-level counts are retained untouched for transparency.
+		if agg.Summary.Dangerous != 1 {
+			t.Errorf("raw Summary.Dangerous must keep the threat-level count, got %d", agg.Summary.Dangerous)
+		}
+	})
+
+	t.Run("hard-tier baseline finding yields dangerous", func(t *testing.T) {
+		agg := AggregateReports("j2", "server-a", []*ScanReport{
+			{
+				ID: "r1", ScannerID: inProcessTPAScannerID,
+				Findings: []ScanFinding{
+					{RuleID: "detect/phrase_injection", Tier: TierHard, ThreatLevel: ThreatLevelDangerous, ThreatType: "prompt_injection", Severity: SeverityCritical, Title: "injection"},
+				},
+			},
+		})
+		if agg.Verdict != "dangerous" {
+			t.Errorf("hard-tier baseline finding must yield 'dangerous', got %q", agg.Verdict)
+		}
+		if agg.FindingCounts == nil || agg.FindingCounts.Dangerous != 1 {
+			t.Errorf("expected FindingCounts.Dangerous=1, got %+v", agg.FindingCounts)
+		}
+	})
+
+	t.Run("soft-tier baseline finding yields warnings", func(t *testing.T) {
+		agg := AggregateReports("j3", "server-a", []*ScanReport{
+			{
+				ID: "r1", ScannerID: inProcessTPAScannerID,
+				Findings: []ScanFinding{
+					{RuleID: "detect/directive_imperative", Tier: TierSoft, ThreatLevel: ThreatLevelWarning, ThreatType: "tool_poisoning", Severity: SeverityMedium, Title: "directive"},
+				},
+			},
+		})
+		if agg.Verdict != "warnings" {
+			t.Errorf("soft-tier baseline finding must yield 'warnings', got %q", agg.Verdict)
+		}
+	})
+
+	t.Run("no findings yields clean", func(t *testing.T) {
+		agg := AggregateReports("j4", "server-a", []*ScanReport{{ID: "r1", ScannerID: "trivy"}})
+		if agg.Verdict != "clean" {
+			t.Errorf("expected 'clean' for empty findings, got %q", agg.Verdict)
+		}
+	})
+}