Commit `7b41195620`

7b41195620eadd54d25fa98dcd36735cba906ba3

parent: 36ea668d7f

Verified · cmc

cmc <hello@cleberg.net> · 2026-04-22 14:47 UTC

feat(v2.7.0): add provenance, confidence, and reproducibility metadata

* add result provenance across major sections
* introduce confidence levels for ambiguous outputs
* distinguish observed facts from inferred summaries
* expand snapshot metadata for reproducibility
* improve error classification and partial snapshot handling
* include provenance and confidence in export
* add local notes for tracked domains and history

Layout: unified · split

DomainDig.xcodeproj/project.pbxproj +6 −6

	@@ -134,7 +134,7 @@
134	};	134	};
135	8BF124FB2F70000100933221 /* DomainDigCLI */ = {	135	8BF124FB2F70000100933221 /* DomainDigCLI */ = {
136	isa = PBXNativeTarget;	136	isa = PBXNativeTarget;
137	buildConfigurationList = 8BBFF0292F987EF700E8E144 /* Build configuration list */;	137	buildConfigurationList = 8BBFF0292F987EF700E8E144 /* Build configuration list for PBXNativeTarget "DomainDigCLI" */;
138	buildPhases = (	138	buildPhases = (
139	8BF124FC2F70000100933221 /* Sources */,	139	8BF124FC2F70000100933221 /* Sources */,
140	8BF124FD2F70000100933221 /* Frameworks */,	140	8BF124FD2F70000100933221 /* Frameworks */,
	@@ -354,7 +354,7 @@
354	ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;	354	ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
355	ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;	355	ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
356	CODE_SIGN_STYLE = Automatic;	356	CODE_SIGN_STYLE = Automatic;
357	CURRENT_PROJECT_VERSION = 19;	357	CURRENT_PROJECT_VERSION = 20;
358	DEVELOPMENT_TEAM = ZCNAX3VL9D;	358	DEVELOPMENT_TEAM = ZCNAX3VL9D;
359	ENABLE_PREVIEWS = YES;	359	ENABLE_PREVIEWS = YES;
360	GENERATE_INFOPLIST_FILE = YES;	360	GENERATE_INFOPLIST_FILE = YES;
	@@ -371,7 +371,7 @@
371	"$(inherited)",	371	"$(inherited)",
372	"@executable_path/Frameworks",	372	"@executable_path/Frameworks",
373	);	373	);
374	MARKETING_VERSION = 2.6.0;	374	MARKETING_VERSION = 2.7.0;
375	PRODUCT_BUNDLE_IDENTIFIER = net.cleberg.DomainDig;	375	PRODUCT_BUNDLE_IDENTIFIER = net.cleberg.DomainDig;
376	PRODUCT_NAME = "$(TARGET_NAME)";	376	PRODUCT_NAME = "$(TARGET_NAME)";
377	STRING_CATALOG_GENERATE_SYMBOLS = YES;	377	STRING_CATALOG_GENERATE_SYMBOLS = YES;
	@@ -390,7 +390,7 @@
390	ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;	390	ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
391	ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;	391	ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
392	CODE_SIGN_STYLE = Automatic;	392	CODE_SIGN_STYLE = Automatic;
393	CURRENT_PROJECT_VERSION = 19;	393	CURRENT_PROJECT_VERSION = 20;
394	DEVELOPMENT_TEAM = ZCNAX3VL9D;	394	DEVELOPMENT_TEAM = ZCNAX3VL9D;
395	ENABLE_PREVIEWS = YES;	395	ENABLE_PREVIEWS = YES;
396	GENERATE_INFOPLIST_FILE = YES;	396	GENERATE_INFOPLIST_FILE = YES;
	@@ -407,7 +407,7 @@
407	"$(inherited)",	407	"$(inherited)",
408	"@executable_path/Frameworks",	408	"@executable_path/Frameworks",
409	);	409	);
410	MARKETING_VERSION = 2.6.0;	410	MARKETING_VERSION = 2.7.0;
411	PRODUCT_BUNDLE_IDENTIFIER = net.cleberg.DomainDig;	411	PRODUCT_BUNDLE_IDENTIFIER = net.cleberg.DomainDig;
412	PRODUCT_NAME = "$(TARGET_NAME)";	412	PRODUCT_NAME = "$(TARGET_NAME)";
413	STRING_CATALOG_GENERATE_SYMBOLS = YES;	413	STRING_CATALOG_GENERATE_SYMBOLS = YES;
	@@ -460,7 +460,7 @@
460	defaultConfigurationIsVisible = 0;	460	defaultConfigurationIsVisible = 0;
461	defaultConfigurationName = Release;	461	defaultConfigurationName = Release;
462	};	462	};
463	8BBFF0292F987EF700E8E144 /* Build configuration list */ = {	463	8BBFF0292F987EF700E8E144 /* Build configuration list for PBXNativeTarget "DomainDigCLI" */ = {
464	isa = XCConfigurationList;	464	isa = XCConfigurationList;
465	buildConfigurations = (	465	buildConfigurations = (
466	8BBFF0272F987E8700E8E144 /* Debug */,	466	8BBFF0272F987E8700E8E144 /* Debug */,

DomainDig/AppVersion.swift added +7

@@ -0,0 +1,7 @@
	1	import Foundation
	2
	3	enum AppVersion {
	4	static var current: String {
	5	"2.7.0"
	6	}
	7	}

DomainDig/ContentView.swift +190 −36

                     }
                     if viewModel.hasRun {
                         actionButtons
-                        if let statusMessage = resultStatusMessage {
+                        if !viewModel.resultsLoaded {
+                            LookupProgressOverviewView(steps: viewModel.activeLoadingLabels)
+                                .padding(.top, appDensity.metrics.cardSpacing)
+                        } else if let statusMessage = resultStatusMessage {
                             LookupStatusBannerView(message: statusMessage, resultSource: viewModel.currentResultSource)
                                 .padding(.top, appDensity.metrics.cardSpacing)
                         }
-                        SummaryView(fields: viewModel.summaryFields)
+                        if viewModel.resultsLoaded {
-                            .padding(.top, appDensity.metrics.cardSpacing)
+                            SummaryView(fields: viewModel.summaryFields)
-                        if let changeSummary = viewModel.currentChangeSummary {
-                            DomainChangeSummaryView(summary: changeSummary)
                                 .padding(.top, appDensity.metrics.cardSpacing)
+                            if let changeSummary = viewModel.currentChangeSummary {
+                                DomainChangeSummaryView(summary: changeSummary)
+                                    .padding(.top, appDensity.metrics.cardSpacing)
+                            }
                         }
                         DomainSectionView(
                             isCollapsed: sectionCollapsedBinding(.domain),
                             showSuggestions: viewModel.availabilityResult?.status == .registered || viewModel.suggestionsLoading,
                             availabilityLoading: viewModel.availabilityLoading,
                             suggestionsLoading: viewModel.suggestionsLoading,
+                            provenance: viewModel.currentSnapshot.provenanceBySection[.availability],
+                            confidence: viewModel.currentSnapshot.availabilityConfidence,
+                            snapshotNote: viewModel.currentSnapshot.note,
                             trackedDomain: viewModel.currentTrackedDomain,
                             trackingLimitMessage: viewModel.trackingLimitMessage,
                             onTrack: {
                             rows: viewModel.ownershipRows,
                             loading: viewModel.ownershipLoading,
                             error: viewModel.ownershipError,
+                            provenance: viewModel.currentSnapshot.provenanceBySection[.ownership],
+                            confidence: viewModel.currentSnapshot.ownershipConfidence,
                             showsHistoryPlaceholder: !DataAccessService.hasAccess(to: .ownershipHistory)
                         )
                         .padding(.top, appDensity.metrics.sectionSpacing)
                             rows: viewModel.subdomainRows,
                             loading: viewModel.subdomainsLoading,
                             error: viewModel.subdomainsError,
+                            provenance: viewModel.currentSnapshot.provenanceBySection[.subdomains],
+                            confidence: viewModel.currentSnapshot.subdomainConfidence,
                             showsExtendedPlaceholder: !DataAccessService.hasAccess(to: .extendedSubdomains)
                         )
                         .padding(.top, appDensity.metrics.sectionSpacing)
                             DomainDiffView(
                                 title: "Latest Changes",
                                 sections: viewModel.currentDiffSections,
+                                contextNote: viewModel.currentChangeSummary?.contextNote,
                                 showsUnchanged: false
                             )
                             .padding(.top, appDensity.metrics.sectionSpacing)
                             sections: viewModel.dnsRows,
                             ptrMessage: viewModel.ptrMessage,
                             loading: viewModel.dnsLoading || viewModel.ptrLoading,
+                            dnsProvenance: viewModel.currentSnapshot.provenanceBySection[.dns],
+                            ptrProvenance: viewModel.currentSnapshot.provenanceBySection[.ptr],
                             sectionError: viewModel.dnsError
                         )
                         .padding(.top, appDensity.metrics.sectionSpacing)
                             sslInfo: viewModel.sslInfo,
                             sslLoading: viewModel.sslLoading || viewModel.hstsLoading,
                             sslError: viewModel.sslError,
+                            tlsProvenance: viewModel.currentSnapshot.provenanceBySection[.ssl],
                             responseRows: viewModel.webResponseRows,
                             headers: viewModel.httpHeaders,
                             headersLoading: viewModel.httpHeadersLoading,
                             headersError: viewModel.httpHeadersError,
+                            httpProvenance: viewModel.currentSnapshot.provenanceBySection[.httpHeaders],
                             redirects: viewModel.redirectRows,
                             redirectLoading: viewModel.redirectChainLoading,
                             redirectError: viewModel.redirectChainError,
+                            redirectProvenance: viewModel.currentSnapshot.provenanceBySection[.redirectChain],
                             finalURL: viewModel.currentSnapshot.redirectChain.last?.url
                         )
                         .padding(.top, appDensity.metrics.sectionSpacing)
                             isCollapsed: sectionCollapsedBinding(.email),
                             rows: viewModel.emailRows,
                             loading: viewModel.emailSecurityLoading,
+                            provenance: viewModel.currentSnapshot.provenanceBySection[.emailSecurity],
+                            confidence: viewModel.currentSnapshot.emailSecurityConfidence,
                             error: viewModel.emailSecurityError
                         )
                         .padding(.top, appDensity.metrics.sectionSpacing)
                             reachabilityRows: viewModel.reachabilityRows,
                             reachabilityLoading: viewModel.reachabilityLoading,
                             reachabilityError: viewModel.reachabilityError,
+                            reachabilityProvenance: viewModel.currentSnapshot.provenanceBySection[.reachability],
                             locationRows: viewModel.locationRows,
                             geolocation: viewModel.ipGeolocation,
                             geolocationLoading: viewModel.ipGeolocationLoading,
                             geolocationError: viewModel.ipGeolocationError,
+                            geolocationProvenance: viewModel.currentSnapshot.provenanceBySection[.ipGeolocation],
+                            geolocationConfidence: viewModel.currentSnapshot.geolocationConfidence,
                             standardPortRows: viewModel.standardPortRows,
                             customPortRows: viewModel.customPortRows,
                             portScanLoading: viewModel.portScanLoading,
                             portScanError: viewModel.portScanError,
+                            portScanProvenance: viewModel.currentSnapshot.provenanceBySection[.portScan],
                             customPortScanLoading: viewModel.customPortScanLoading,
                             customPortScanError: viewModel.customPortScanError,
                             isCloudflareProxied: viewModel.isCloudflareProxied,
                 .padding(.horizontal)
                 .padding(.bottom, 32)
             }
-            .safeAreaInset(edge: .top) {
-                if viewModel.hasRun {
-                    StickyLookupSummaryView(
-                        domain: viewModel.searchedDomain,
-                        availability: viewModel.availabilityResult?.status,
-                        primaryIP: currentPrimaryIP,
-                        sslInfo: viewModel.sslInfo,
-                        sslError: viewModel.sslError,
-                        emailSecurity: viewModel.emailSecurity,
-                        emailError: viewModel.emailSecurityError,
-                        changeSummary: viewModel.currentChangeSummary
-                    )
-                    .padding(.horizontal)
-                    .padding(.top, 6)
-                    .background {
-                        Rectangle()
-                            .fill(.ultraThinMaterial)
-                            .opacity(0.96)
-                    }
-                }
-            }
             .background(
                 LinearGradient(
                     colors: [Color.black, Color(.systemGray6).opacity(0.12)],
     }
     private var defaultCollapsedSections: Set<ResultSection> {
-        var sections: Set<ResultSection> = []
+        []
-        if viewModel.standardPortRows.count + viewModel.customPortRows.count > 6 || currentPrimaryIP == nil {
-            sections.insert(.network)
-        }
-        return sections
     }
     private var currentPrimaryIP: String? {
     }
 }
+struct LookupProgressOverviewView: View {
+    @Environment(\.appDensity) private var appDensity
+    let steps: [String]
+    var body: some View {
+        CardView(allowsHorizontalScroll: false) {
+            HStack(spacing: 8) {
+                ProgressView()
+                    .controlSize(.small)
+                VStack(alignment: .leading, spacing: 4) {
+                    Text("Running lookup…")
+                        .font(appDensity.font(.caption))
+                        .foregroundStyle(.primary)
+                    Text(steps.isEmpty ? "Preparing requests" : steps.joined(separator: " • "))
+                        .font(appDensity.font(.caption2))
+                        .foregroundStyle(.secondary)
+                }
+                Spacer()
+            }
+        }
+    }
+}
 struct LookupStatusBannerView: View {
     @Environment(\.appDensity) private var appDensity
     let message: String
 struct DomainChangeSummaryView: View {
     @Environment(\.appDensity) private var appDensity
     let summary: DomainChangeSummary
+    @State private var showsDetails = false
     var body: some View {
         CardView(allowsHorizontalScroll: false) {
                     .foregroundStyle(.secondary)
             }
-            Text(summary.message)
+            VStack(alignment: .leading, spacing: 4) {
+                Text("Inference")
+                    .font(appDensity.font(.caption2))
+                    .foregroundStyle(.secondary)
+                Text(summary.message)
+                    .font(appDensity.font(.caption))
+                    .foregroundStyle(.primary)
+                    .lineLimit(2)
+            }
+            if !summary.observedFacts.isEmpty || summary.contextNote != nil {
+                DisclosureGroup(showsDetails ? "Hide Details" : "Show Details", isExpanded: $showsDetails) {
+                    VStack(alignment: .leading, spacing: 8) {
+                        if !summary.observedFacts.isEmpty {
+                            VStack(alignment: .leading, spacing: 4) {
+                                Text("Observed")
+                                    .font(appDensity.font(.caption2))
+                                    .foregroundStyle(.secondary)
+                                ForEach(Array(summary.observedFacts.enumerated()), id: \.offset) { _, fact in
+                                    Text(fact)
+                                        .font(appDensity.font(.caption))
+                                        .foregroundStyle(.primary)
+                                }
+                            }
+                        }
+                        if let contextNote = summary.contextNote {
+                            Text(contextNote)
+                                .font(appDensity.font(.caption2))
+                                .foregroundStyle(.orange)
+                        }
+                    }
+                    .padding(.top, 4)
+                }
                 .font(appDensity.font(.caption))
-                .foregroundStyle(.primary)
+                .tint(.secondary)
+            }
         }
     }
 struct DomainDiffView: View {
     let title: String
     let sections: [DomainDiffSection]
+    let contextNote: String?
     let showsUnchanged: Bool
     @State private var collapsedSections = Set<UUID>()
                     .font(.system(.caption, design: .monospaced))
                 }
             }
+            if let contextNote {
+                MessageCardView(text: contextNote, isError: false)
+            }
             if filteredSections.isEmpty {
                 MessageCardView(text: "No comparison data available", isError: false)
             } else {
     let showSuggestions: Bool
     let availabilityLoading: Bool
     let suggestionsLoading: Bool
+    let provenance: SectionProvenance?
+    let confidence: ConfidenceLevel?
+    let snapshotNote: String?
     let trackedDomain: TrackedDomain?
     let trackingLimitMessage: String?
     let onTrack: () -> Void
             }
         } content: {
             CardView(allowsHorizontalScroll: false) {
+                SectionTrustMetadataView(
+                    provenance: provenance,
+                    confidence: confidence,
+                    note: snapshotNote == nil ? nil : "Audit note present"
+                )
                 ForEach(rows) { row in
                     LabeledValueRow(row: row)
                 }
                                     .foregroundStyle(.primary)
                                     .textSelection(.enabled)
                                 Spacer()
-                                AppStatusBadgeView(model: AppStatusFactory.availability(suggestion.status == "Available" ? .available : .registered))
+                                AppStatusBadgeView(model: AppStatusFactory.availability(suggestion.availabilityStatus))
                             }
                         }
                     }
     let rows: [InfoRowViewData]
     let loading: Bool
     let error: String?
+    let provenance: SectionProvenance?
+    let confidence: ConfidenceLevel?
     let showsHistoryPlaceholder: Bool
     var body: some View {
         CollapsibleSectionView(title: "Ownership", isCollapsed: $isCollapsed) {
             CardView(allowsHorizontalScroll: false) {
+                SectionTrustMetadataView(provenance: provenance, confidence: confidence)
                 if loading {
                     ProgressView("Fetching RDAP ownership…")
                         .appLoadingStyle()
     let rows: [SubdomainRowViewData]
     let loading: Bool
     let error: String?
+    let provenance: SectionProvenance?
+    let confidence: ConfidenceLevel?
     let showsExtendedPlaceholder: Bool
     var body: some View {
         CollapsibleSectionView(title: "Subdomains", isCollapsed: $isCollapsed, subtitle: "\(rows.count) found") {
             CardView(allowsHorizontalScroll: false) {
+                SectionTrustMetadataView(provenance: provenance, confidence: confidence)
                 if loading {
                     ProgressView("Checking certificate transparency…")
                         .appLoadingStyle()
     let sections: [DNSRecordSectionViewData]
     let ptrMessage: SectionMessageViewData?
     let loading: Bool
+    let dnsProvenance: SectionProvenance?
+    let ptrProvenance: SectionProvenance?
     let sectionError: String?
     var body: some View {
             } else if let sectionError, sections.isEmpty {
                 MessageCardView(text: sectionError, isError: true)
             } else {
+                if dnsProvenance != nil {
+                    CardView(allowsHorizontalScroll: false) {
+                        SectionTrustMetadataView(provenance: dnsProvenance, confidence: nil)
+                    }
+                }
                 ForEach(sections) { section in
                     CardView {
                         Text(section.title)
                             .font(.system(.subheadline, design: .monospaced))
                             .fontWeight(.semibold)
                             .foregroundStyle(.cyan)
+                        SectionTrustMetadataView(provenance: ptrProvenance, confidence: nil)
                         MessageRowView(text: ptrMessage.text, isError: ptrMessage.isError)
                     }
                 }
     let sslInfo: SSLCertificateInfo?
     let sslLoading: Bool
     let sslError: String?
+    let tlsProvenance: SectionProvenance?
     let responseRows: [InfoRowViewData]
     let headers: [HTTPHeader]
     let headersLoading: Bool
     let headersError: String?
+    let httpProvenance: SectionProvenance?
     let redirects: [RedirectHopViewData]
     let redirectLoading: Bool
     let redirectError: String?
+    let redirectProvenance: SectionProvenance?
     let finalURL: String?
     var body: some View {
                     Spacer()
                     AppStatusBadgeView(model: AppStatusFactory.tls(sslInfo: sslInfo, error: sslError))
                 }
+                SectionTrustMetadataView(provenance: tlsProvenance, confidence: nil)
                 if sslLoading {
                     ProgressView("Checking certificate…")
                         .appLoadingStyle()
                 Text("Headers")
                     .font(appDensity.font(.subheadline, weight: .semibold))
                     .foregroundStyle(.cyan)
+                SectionTrustMetadataView(provenance: httpProvenance, confidence: nil)
                 if headersLoading {
                     ProgressView("Fetching headers…")
                         .appLoadingStyle()
                         AppCopyButton(value: finalURL, label: "Copy redirect URL")
                     }
                 }
+                SectionTrustMetadataView(provenance: redirectProvenance, confidence: nil)
                 if redirectLoading {
                     ProgressView("Tracing redirects…")
                         .appLoadingStyle()
     @Binding var isCollapsed: Bool
     let rows: [EmailRowViewData]
     let loading: Bool
+    let provenance: SectionProvenance?
+    let confidence: ConfidenceLevel?
     let error: String?
     var body: some View {
         CollapsibleSectionView(title: "Email", isCollapsed: $isCollapsed) {
             CardView {
+                SectionTrustMetadataView(provenance: provenance, confidence: confidence)
                 HStack {
                     Spacer()
                     AppStatusBadgeView(model: AppStatusFactory.email(nil, error: error))
     let reachabilityRows: [ReachabilityRowViewData]
     let reachabilityLoading: Bool
     let reachabilityError: String?
+    let reachabilityProvenance: SectionProvenance?
     let locationRows: [InfoRowViewData]
     let geolocation: IPGeolocation?
     let geolocationLoading: Bool
     let geolocationError: String?
+    let geolocationProvenance: SectionProvenance?
+    let geolocationConfidence: ConfidenceLevel?
     let standardPortRows: [PortScanRowViewData]
     let customPortRows: [PortScanRowViewData]
     let portScanLoading: Bool
     let portScanError: String?
+    let portScanProvenance: SectionProvenance?
     let customPortScanLoading: Bool
     let customPortScanError: String?
     let isCloudflareProxied: Bool
                 Text("Reachability")
                     .font(appDensity.font(.subheadline, weight: .semibold))
                     .foregroundStyle(.cyan)
+                SectionTrustMetadataView(provenance: reachabilityProvenance, confidence: nil)
                 if reachabilityLoading {
                     ProgressView("Checking ports…")
                         .appLoadingStyle()
                 Text("Location")
                     .font(appDensity.font(.subheadline, weight: .semibold))
                     .foregroundStyle(.cyan)
+                SectionTrustMetadataView(provenance: geolocationProvenance, confidence: geolocationConfidence)
                 if geolocationLoading {
                     ProgressView("Looking up location…")
                         .appLoadingStyle()
                 Text("Port Scan")
                     .font(appDensity.font(.subheadline, weight: .semibold))
                     .foregroundStyle(.cyan)
+                SectionTrustMetadataView(provenance: portScanProvenance, confidence: nil)
                 if isCloudflareProxied {
                     Text("Domain is behind Cloudflare's proxy. Results reflect the edge, not the origin.")
     }
 }
+struct SectionTrustMetadataView: View {
+    @Environment(\.appDensity) private var appDensity
+    let provenance: SectionProvenance?
+    let confidence: ConfidenceLevel?
+    let note: String?
+    init(provenance: SectionProvenance?, confidence: ConfidenceLevel?, note: String? = nil) {
+        self.provenance = provenance
+        self.confidence = confidence
+        self.note = note
+    }
+    var body: some View {
+        if provenance != nil || confidence != nil || note != nil {
+            VStack(alignment: .leading, spacing: 6) {
+                HStack(spacing: 8) {
+                    if let confidence {
+                        Text("Confidence \(confidence.title)")
+                            .font(appDensity.font(.caption2))
+                            .foregroundStyle(.secondary)
+                    }
+                    if let provenance {
+                        Text(provenance.provider ?? provenance.source)
+                            .font(appDensity.font(.caption2))
+                            .foregroundStyle(.secondary)
+                        Text(provenance.resultSource.label)
+                            .font(appDensity.font(.caption2))
+                            .foregroundStyle(.secondary)
+                    }
+                }
+                DisclosureGroup("Details") {
+                    VStack(alignment: .leading, spacing: 4) {
+                        if let provenance {
+                            LabeledValueRow(row: .init(label: "Method", value: provenance.source, tone: .secondary))
+                            if let provider = provenance.provider {
+                                LabeledValueRow(row: .init(label: "Provider", value: provider, tone: .secondary))
+                            }
+                            if let resolver = provenance.resolver {
+                                LabeledValueRow(row: .init(label: "Resolver", value: resolver, tone: .secondary))
+                            }
+                            LabeledValueRow(row: .init(label: "Collected", value: provenance.collectedAt.formatted(date: .abbreviated, time: .shortened), tone: .secondary))
+                            LabeledValueRow(row: .init(label: "Mode", value: provenance.resultSource.label, tone: .secondary))
+                        }
+                        if let note {
+                            LabeledValueRow(row: .init(label: "Note", value: note, tone: .secondary))
+                        }
+                    }
+                    .padding(.top, 4)
+                }
+                .font(appDensity.font(.caption))
+                .tint(.secondary)
+            }
+        }
+    }
+}
 struct LabeledValueRow: View {
     @Environment(\.appDensity) private var appDensity
     let row: InfoRowViewData
             Section("About") {
                 LabeledContent("Version", value: appVersion)
                 LabeledContent("Storage", value: "Local-only")
-                LabeledContent("Focus", value: "Readable domain inspection")
             }
         }
         .navigationTitle("Settings")
     }
     private var appVersion: String {
-        Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "2.6.0"
+        AppVersion.current
     }
 }

DomainDig/DomainAvailabilityService.swift +6 −2

         }
         let fallbackStatus = await checkViaDNSFallback(domain: normalizedDomain)
-        let method = fallbackStatus == .registered ? "dns" : "fallback"
+        if fallbackStatus == .registered {
-        debugLog(method, domain: normalizedDomain, status: fallbackStatus)
+            debugLog("dns-evidence", domain: normalizedDomain, details: "DNS exists but RDAP did not confirm registration")
+            return DomainAvailabilityResult(domain: normalizedDomain, status: .unknown)
+        }
+        debugLog("fallback", domain: normalizedDomain, status: fallbackStatus)
         return DomainAvailabilityResult(domain: normalizedDomain, status: fallbackStatus)
     }

DomainDig/DomainDiffService.swift +26 −1

	@@ -67,16 +67,33 @@ enum DomainDiffService {
67	let highlights = summaryHighlights(from: allChangedItems)	67	let highlights = summaryHighlights(from: allChangedItems)
68	let severity = allChangedItems.map(\.severity).max() ?? .low	68	let severity = allChangedItems.map(\.severity).max() ?? .low
69	let message = summaryMessage(from: allChangedItems, highlights: highlights)	69	let message = summaryMessage(from: allChangedItems, highlights: highlights)
		70	let observedFacts = observedFacts(from: allChangedItems)
		71	let inferredConclusions = highlights.isEmpty ? [] : [message]
		72	let contextNote = comparisonContextNote(from: oldSnapshot, to: newSnapshot)
70		73
71	return DomainChangeSummary(	74	return DomainChangeSummary(
72	hasChanges: !allChangedItems.isEmpty,	75	hasChanges: !allChangedItems.isEmpty,
73	changedSections: highlights,	76	changedSections: highlights,
74	message: message,	77	message: message,
75	severity: severity,	78	severity: severity,
76	generatedAt: generatedAt	79	generatedAt: generatedAt,
		80	observedFacts: observedFacts,
		81	inferredConclusions: inferredConclusions,
		82	contextNote: contextNote
77	)	83	)
78	}	84	}
79		85
		86	static func comparisonContextNote(from oldSnapshot: LookupSnapshot, to newSnapshot: LookupSnapshot) -> String? {
		87	var notes: [String] = []
		88	if oldSnapshot.resolverURLString != newSnapshot.resolverURLString {
		89	notes.append("Compared snapshots used different DNS resolvers.")
		90	}
		91	if oldSnapshot.resultSource != newSnapshot.resultSource {
		92	notes.append("Compared snapshots came from different collection modes.")
		93	}
		94	return notes.isEmpty ? nil : notes.joined(separator: " ")
		95	}
		96
80	static func certificateWarningLevel(for snapshot: LookupSnapshot) -> CertificateWarningLevel {	97	static func certificateWarningLevel(for snapshot: LookupSnapshot) -> CertificateWarningLevel {
81	guard let days = snapshot.sslInfo?.daysUntilExpiry else {	98	guard let days = snapshot.sslInfo?.daysUntilExpiry else {
82	return .none	99	return .none
	@@ -410,6 +427,14 @@ enum DomainDiffService {
410	return "\(highlights[0]) and \(highlights[1].lowercased())"	427	return "\(highlights[0]) and \(highlights[1].lowercased())"
411	}	428	}
412		429
		430	private static func observedFacts(from items: [DomainDiffItem]) -> [String] {
		431	items.prefix(3).map { item in
		432	let oldValue = item.oldValue ?? "none"
		433	let newValue = item.newValue ?? "none"
		434	return "\(item.label): \(oldValue) -> \(newValue)"
		435	}
		436	}
		437
413	private static func normalized(_ value: String?) -> String? {	438	private static func normalized(_ value: String?) -> String? {
414	guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {	439	guard let value = value?.trimmingCharacters(in: .whitespacesAndNewlines), !value.isEmpty else {
415	return nil	440	return nil

DomainDig/DomainViewModel.swift +169 −18

	@@ -87,6 +87,7 @@ struct SubdomainRowViewData: Identifiable {
87	struct DomainSuggestionViewData: Identifiable {	87	struct DomainSuggestionViewData: Identifiable {
88	let id: UUID	88	let id: UUID
89	let domain: String	89	let domain: String
		90	let availabilityStatus: DomainAvailabilityStatus
90	let status: String	91	let status: String
91	let tone: ResultTone	92	let tone: ResultTone
92	}	93	}
	@@ -204,13 +205,7 @@ final class DomainViewModel {
204		205
205	private static let historyKey = "lookupHistory"	206	private static let historyKey = "lookupHistory"
206	private static let maxHistory = 250	207	private static let maxHistory = 250
207	var history: [HistoryEntry] = {	208	var history: [HistoryEntry] = DomainViewModel.loadHistoryEntries()
208	guard let data = UserDefaults.standard.data(forKey: historyKey),
209	let entries = try? JSONDecoder().decode([HistoryEntry].self, from: data) else {
210	return []
211	}
212	return entries
213	}()
214	var historySearchText = ""	209	var historySearchText = ""
215	var historyDateFilter: HistoryDateFilter = .all	210	var historyDateFilter: HistoryDateFilter = .all
216	var historyChangeFilter: ChangeFilterOption = .all	211	var historyChangeFilter: ChangeFilterOption = .all
	@@ -246,6 +241,24 @@ final class DomainViewModel {
246	!customPortScanLoading	241	!customPortScanLoading
247	}	242	}
248		243
		244	var activeLoadingLabels: [String] {
		245	var labels: [String] = []
		246	if availabilityLoading { labels.append("Availability") }
		247	if dnsLoading { labels.append("DNS") }
		248	if sslLoading \|\| hstsLoading { labels.append("TLS") }
		249	if httpHeadersLoading { labels.append("HTTP") }
		250	if ownershipLoading { labels.append("Ownership") }
		251	if emailSecurityLoading { labels.append("Email") }
		252	if subdomainsLoading { labels.append("Subdomains") }
		253	if redirectChainLoading { labels.append("Redirects") }
		254	if reachabilityLoading { labels.append("Reachability") }
		255	if ipGeolocationLoading { labels.append("Geolocation") }
		256	if ptrLoading { labels.append("PTR") }
		257	if portScanLoading { labels.append("Port Scan") }
		258	if customPortScanLoading { labels.append("Custom Ports") }
		259	return labels
		260	}
		261
249	var isCloudflareProxied: Bool {	262	var isCloudflareProxied: Bool {
250	httpHeaders.contains { $0.name.lowercased() == "cf-ray" }	263	httpHeaders.contains { $0.name.lowercased() == "cf-ray" }
251	}	264	}
	@@ -365,8 +378,20 @@ final class DomainViewModel {
365	domain: searchedDomain,	378	domain: searchedDomain,
366	timestamp: currentSnapshotTimestamp,	379	timestamp: currentSnapshotTimestamp,
367	trackedDomainID: currentTrackedDomain?.id,	380	trackedDomainID: currentTrackedDomain?.id,
		381	note: currentHistoryEntry?.note ?? currentTrackedDomain?.note,
		382	appVersion: AppVersion.current,
368	resolverDisplayName: resolverDisplayName,	383	resolverDisplayName: resolverDisplayName,
369	resolverURLString: resolverURLString,	384	resolverURLString: resolverURLString,
		385	dataSources: currentHistoryEntry?.dataSources ?? [],
		386	provenanceBySection: currentHistoryEntry?.provenanceBySection ?? [:],
		387	availabilityConfidence: currentHistoryEntry?.availabilityConfidence,
		388	ownershipConfidence: currentHistoryEntry?.ownershipConfidence,
		389	subdomainConfidence: currentHistoryEntry?.subdomainConfidence,
		390	emailSecurityConfidence: currentHistoryEntry?.emailSecurityConfidence,
		391	geolocationConfidence: currentHistoryEntry?.geolocationConfidence,
		392	errorDetails: currentHistoryEntry?.errorDetails ?? [:],
		393	isPartialSnapshot: currentHistoryEntry?.isPartialSnapshot ?? false,
		394	validationIssues: currentHistoryEntry?.validationIssues ?? [],
370	totalLookupDurationMs: lastLookupDurationMs,	395	totalLookupDurationMs: lastLookupDurationMs,
371	dnsSections: dnsSections,	396	dnsSections: dnsSections,
372	dnsError: dnsError,	397	dnsError: dnsError,
	@@ -405,6 +430,11 @@ final class DomainViewModel {
405	)	430	)
406	}	431	}
407		432
		433	private var currentHistoryEntry: HistoryEntry? {
		434	guard let currentHistoryEntryID else { return nil }
		435	return history.first(where: { $0.id == currentHistoryEntryID })
		436	}
		437
408	var currentReport: DomainReport? {	438	var currentReport: DomainReport? {
409	guard !searchedDomain.isEmpty else { return nil }	439	guard !searchedDomain.isEmpty else { return nil }
410	return reportBuilder.build(	440	return reportBuilder.build(
	@@ -543,9 +573,7 @@ final class DomainViewModel {
543	}	573	}
544		574
545	func rerunInspection(for trackedDomain: TrackedDomain) {	575	func rerunInspection(for trackedDomain: TrackedDomain) {
546	domain = trackedDomain.domain	576	rerunInspection(for: trackedDomain, useSnapshotResolver: false)
547	run()
548	rerunNavigationToken = UUID()
549	}	577	}
550		578
551	func deleteTrackedDomains(at offsets: IndexSet) {	579	func deleteTrackedDomains(at offsets: IndexSet) {
	@@ -609,13 +637,24 @@ final class DomainViewModel {
609	UserDefaults.standard.removeObject(forKey: Self.recentSearchesKey)	637	UserDefaults.standard.removeObject(forKey: Self.recentSearchesKey)
610	}	638	}
611		639
612	func rerunLookup(from entry: HistoryEntry) {	640	func rerunLookup(from entry: HistoryEntry, useSnapshotResolver: Bool) {
613	UserDefaults.standard.set(entry.resolverURLString, forKey: DNSResolverOption.userDefaultsKey)	641	if useSnapshotResolver {
		642	UserDefaults.standard.set(entry.resolverURLString, forKey: DNSResolverOption.userDefaultsKey)
		643	}
614	domain = entry.domain	644	domain = entry.domain
615	run()	645	run()
616	rerunNavigationToken = UUID()	646	rerunNavigationToken = UUID()
617	}	647	}
618		648
		649	func rerunInspection(for trackedDomain: TrackedDomain, useSnapshotResolver: Bool) {
		650	if useSnapshotResolver, let snapshot = latestSnapshot(for: trackedDomain) {
		651	UserDefaults.standard.set(snapshot.resolverURLString, forKey: DNSResolverOption.userDefaultsKey)
		652	}
		653	domain = trackedDomain.domain
		654	run()
		655	rerunNavigationToken = UUID()
		656	}
		657
619	func reset() {	658	func reset() {
620	lookupTask?.cancel()	659	lookupTask?.cancel()
621	customPortScanTask?.cancel()	660	customPortScanTask?.cancel()
	@@ -853,8 +892,20 @@ final class DomainViewModel {
853	domain: previousSnapshot.domain,	892	domain: previousSnapshot.domain,
854	timestamp: previousSnapshot.timestamp,	893	timestamp: previousSnapshot.timestamp,
855	trackedDomainID: previousSnapshot.trackedDomainID,	894	trackedDomainID: previousSnapshot.trackedDomainID,
		895	note: previousSnapshot.note,
		896	appVersion: previousSnapshot.appVersion,
856	resolverDisplayName: previousSnapshot.resolverDisplayName,	897	resolverDisplayName: previousSnapshot.resolverDisplayName,
857	resolverURLString: previousSnapshot.resolverURLString,	898	resolverURLString: previousSnapshot.resolverURLString,
		899	dataSources: previousSnapshot.dataSources,
		900	provenanceBySection: previousSnapshot.provenanceBySection,
		901	availabilityConfidence: previousSnapshot.availabilityConfidence,
		902	ownershipConfidence: previousSnapshot.ownershipConfidence,
		903	subdomainConfidence: previousSnapshot.subdomainConfidence,
		904	emailSecurityConfidence: previousSnapshot.emailSecurityConfidence,
		905	geolocationConfidence: previousSnapshot.geolocationConfidence,
		906	errorDetails: previousSnapshot.errorDetails,
		907	isPartialSnapshot: previousSnapshot.isPartialSnapshot,
		908	validationIssues: previousSnapshot.validationIssues,
858	totalLookupDurationMs: previousSnapshot.totalLookupDurationMs,	909	totalLookupDurationMs: previousSnapshot.totalLookupDurationMs,
859	dnsSections: previousSnapshot.dnsSections,	910	dnsSections: previousSnapshot.dnsSections,
860	dnsError: previousSnapshot.dnsError,	911	dnsError: previousSnapshot.dnsError,
	@@ -1232,6 +1283,7 @@ final class DomainViewModel {
1232	domain: snapshot.domain,	1283	domain: snapshot.domain,
1233	timestamp: snapshot.timestamp,	1284	timestamp: snapshot.timestamp,
1234	trackedDomainID: trackedDomainID,	1285	trackedDomainID: trackedDomainID,
		1286	note: currentHistoryEntry?.note,
1235	dnsSections: snapshot.dnsSections,	1287	dnsSections: snapshot.dnsSections,
1236	sslInfo: snapshot.sslInfo,	1288	sslInfo: snapshot.sslInfo,
1237	httpHeaders: snapshot.httpHeaders,	1289	httpHeaders: snapshot.httpHeaders,
	@@ -1247,6 +1299,18 @@ final class DomainViewModel {
1247	hstsPreloaded: snapshot.hstsPreloaded,	1299	hstsPreloaded: snapshot.hstsPreloaded,
1248	availabilityResult: snapshot.availabilityResult,	1300	availabilityResult: snapshot.availabilityResult,
1249	suggestions: snapshot.suggestions,	1301	suggestions: snapshot.suggestions,
		1302	appVersion: snapshot.appVersion,
		1303	resultSource: snapshot.resultSource,
		1304	dataSources: snapshot.dataSources,
		1305	provenanceBySection: snapshot.provenanceBySection,
		1306	availabilityConfidence: snapshot.availabilityConfidence,
		1307	ownershipConfidence: snapshot.ownershipConfidence,
		1308	subdomainConfidence: snapshot.subdomainConfidence,
		1309	emailSecurityConfidence: snapshot.emailSecurityConfidence,
		1310	geolocationConfidence: snapshot.geolocationConfidence,
		1311	errorDetails: snapshot.errorDetails,
		1312	isPartialSnapshot: snapshot.isPartialSnapshot,
		1313	validationIssues: snapshot.validationIssues,
1250	resolverDisplayName: snapshot.resolverDisplayName,	1314	resolverDisplayName: snapshot.resolverDisplayName,
1251	resolverURLString: snapshot.resolverURLString,	1315	resolverURLString: snapshot.resolverURLString,
1252	totalLookupDurationMs: snapshot.totalLookupDurationMs,	1316	totalLookupDurationMs: snapshot.totalLookupDurationMs,
	@@ -1302,6 +1366,12 @@ final class DomainViewModel {
1302	}	1366	}
1303	}	1367	}
1304		1368
		1369	func updateHistoryNote(_ note: String, for entry: HistoryEntry) {
		1370	guard let index = history.firstIndex(where: { $0.id == entry.id }) else { return }
		1371	history[index].note = note.trimmingCharacters(in: .whitespacesAndNewlines).nilIfEmpty
		1372	persistHistory()
		1373	}
		1374
1305	private func persistTrackedDomains() {	1375	private func persistTrackedDomains() {
1306	if let data = try? JSONEncoder().encode(trackedDomains) {	1376	if let data = try? JSONEncoder().encode(trackedDomains) {
1307	UserDefaults.standard.set(data, forKey: Self.trackedDomainsKey)	1377	UserDefaults.standard.set(data, forKey: Self.trackedDomainsKey)
	@@ -1777,6 +1847,22 @@ final class DomainViewModel {
1777	trackedDomain.lastChangeSummary ?? recentSnapshots(for: trackedDomain, limit: 1).first?.changeSummary	1847	trackedDomain.lastChangeSummary ?? recentSnapshots(for: trackedDomain, limit: 1).first?.changeSummary
1778	}	1848	}
1779		1849
		1850	func latestSnapshot(for trackedDomain: TrackedDomain) -> LookupSnapshot? {
		1851	recentSnapshots(for: trackedDomain, limit: 1).first?.snapshot
		1852	}
		1853
		1854	func resolverMismatchNote(for entry: HistoryEntry) -> String? {
		1855	guard entry.resolverURLString != resolverURLString else { return nil }
		1856	return "Current resolver differs from this snapshot. Re-running may produce different evidence."
		1857	}
		1858
		1859	func resolverMismatchNote(for trackedDomain: TrackedDomain) -> String? {
		1860	guard let snapshot = latestSnapshot(for: trackedDomain), snapshot.resolverURLString != resolverURLString else {
		1861	return nil
		1862	}
		1863	return "Current resolver differs from the latest snapshot for this tracked domain."
		1864	}
		1865
1780	func comparisonSnapshot(for entry: HistoryEntry) -> LookupSnapshot? {	1866	func comparisonSnapshot(for entry: HistoryEntry) -> LookupSnapshot? {
1781	let siblings = history.filter { candidate in	1867	let siblings = history.filter { candidate in
1782	if let trackedDomainID = entry.trackedDomainID {	1868	if let trackedDomainID = entry.trackedDomainID {
	@@ -1834,8 +1920,20 @@ final class DomainViewModel {
1834	domain: trackedDomain.domain,	1920	domain: trackedDomain.domain,
1835	timestamp: trackedDomain.updatedAt,	1921	timestamp: trackedDomain.updatedAt,
1836	trackedDomainID: trackedDomain.id,	1922	trackedDomainID: trackedDomain.id,
		1923	note: trackedDomain.note,
		1924	appVersion: AppVersion.current,
1837	resolverDisplayName: resolverDisplayName,	1925	resolverDisplayName: resolverDisplayName,
1838	resolverURLString: resolverURLString,	1926	resolverURLString: resolverURLString,
		1927	dataSources: [],
		1928	provenanceBySection: [:],
		1929	availabilityConfidence: nil,
		1930	ownershipConfidence: nil,
		1931	subdomainConfidence: nil,
		1932	emailSecurityConfidence: nil,
		1933	geolocationConfidence: nil,
		1934	errorDetails: [:],
		1935	isPartialSnapshot: true,
		1936	validationIssues: ["No stored snapshot data available"],
1839	totalLookupDurationMs: nil,	1937	totalLookupDurationMs: nil,
1840	dnsSections: [],	1938	dnsSections: [],
1841	dnsError: nil,	1939	dnsError: nil,
	@@ -1874,6 +1972,31 @@ final class DomainViewModel {
1874	)	1972	)
1875	}	1973	}
1876		1974
		1975	private static func loadHistoryEntries() -> [HistoryEntry] {
		1976	let defaults = UserDefaults.standard
		1977	guard let data = defaults.data(forKey: historyKey) else {
		1978	return []
		1979	}
		1980
		1981	if let entries = try? JSONDecoder().decode([HistoryEntry].self, from: data) {
		1982	return entries
		1983	}
		1984
		1985	guard let rawArray = (try? JSONSerialization.jsonObject(with: data)) as? [Any] else {
		1986	return []
		1987	}
		1988
		1989	let decoder = JSONDecoder()
		1990	return rawArray.compactMap { item in
		1991	guard JSONSerialization.isValidJSONObject(item),
		1992	let itemData = try? JSONSerialization.data(withJSONObject: item),
		1993	let entry = try? decoder.decode(HistoryEntry.self, from: itemData) else {
		1994	return nil
		1995	}
		1996	return entry
		1997	}
		1998	}
		1999
1877	private static func loadTrackedDomains() -> [TrackedDomain] {	2000	private static func loadTrackedDomains() -> [TrackedDomain] {
1878	let defaults = UserDefaults.standard	2001	let defaults = UserDefaults.standard
1879	let decoder = JSONDecoder()	2002	let decoder = JSONDecoder()
	@@ -1953,10 +2076,11 @@ final class DomainViewModel {
1953	static func summaryFields(from snapshot: LookupSnapshot) -> [SummaryFieldViewData] {	2076	static func summaryFields(from snapshot: LookupSnapshot) -> [SummaryFieldViewData] {
1954	[	2077	[
1955	SummaryFieldViewData(label: "Domain", value: snapshot.domain.nonEmpty ?? "Unavailable", tone: .primary),	2078	SummaryFieldViewData(label: "Domain", value: snapshot.domain.nonEmpty ?? "Unavailable", tone: .primary),
1956	SummaryFieldViewData(label: "Primary IP", value: primaryIPAddress(from: snapshot) ?? "Unavailable", tone: .primary),	2079	SummaryFieldViewData(label: "Observed IP", value: primaryIPAddress(from: snapshot) ?? "Unavailable", tone: .primary),
1957	SummaryFieldViewData(label: "HTTPS", value: httpsSummary(from: snapshot), tone: httpsSummaryTone(from: snapshot)),	2080	SummaryFieldViewData(label: "Observed Redirect", value: finalRedirectTarget(from: snapshot) ?? "Unavailable", tone: .secondary),
		2081	SummaryFieldViewData(label: "Inference", value: availabilityInference(from: snapshot), tone: availabilityTone(snapshot.availabilityResult?.status)),
		2082	SummaryFieldViewData(label: "Observed TLS", value: httpsSummary(from: snapshot), tone: httpsSummaryTone(from: snapshot)),
1958	SummaryFieldViewData(label: "Certificate", value: certificateStatusLabel(from: snapshot), tone: certificateStatusTone(from: snapshot)),	2083	SummaryFieldViewData(label: "Certificate", value: certificateStatusLabel(from: snapshot), tone: certificateStatusTone(from: snapshot)),
1959	SummaryFieldViewData(label: "Redirect", value: finalRedirectTarget(from: snapshot) ?? "Unavailable", tone: .secondary),
1960	SummaryFieldViewData(label: "Source", value: snapshot.statusMessage ?? snapshot.resultSource.label, tone: sourceTone(for: snapshot))	2084	SummaryFieldViewData(label: "Source", value: snapshot.statusMessage ?? snapshot.resultSource.label, tone: sourceTone(for: snapshot))
1961	]	2085	]
1962	}	2086	}
	@@ -1965,17 +2089,32 @@ final class DomainViewModel {
1965	var rows = [	2089	var rows = [
1966	InfoRowViewData(label: "Domain", value: snapshot.domain, tone: .primary),	2090	InfoRowViewData(label: "Domain", value: snapshot.domain, tone: .primary),
1967	InfoRowViewData(label: "Resolver", value: snapshot.resolverDisplayName, tone: .secondary),	2091	InfoRowViewData(label: "Resolver", value: snapshot.resolverDisplayName, tone: .secondary),
		2092	InfoRowViewData(label: "Collected", value: snapshot.timestamp.formatted(date: .abbreviated, time: .shortened), tone: .secondary),
1968	InfoRowViewData(label: snapshot.statusMessage == nil ? "Result" : "Snapshot", value: snapshot.statusMessage ?? snapshot.resultSource.label, tone: sourceTone(for: snapshot)),	2093	InfoRowViewData(label: snapshot.statusMessage == nil ? "Result" : "Snapshot", value: snapshot.statusMessage ?? snapshot.resultSource.label, tone: sourceTone(for: snapshot)),
1969	InfoRowViewData(label: "Lookup Duration", value: durationLabel(snapshot.totalLookupDurationMs), tone: .secondary)	2094	InfoRowViewData(label: "Lookup Duration", value: durationLabel(snapshot.totalLookupDurationMs), tone: .secondary)
1970	]	2095	]
1971	rows.insert(	2096	rows.insert(
1972	InfoRowViewData(	2097	InfoRowViewData(
1973	label: "Availability",	2098	label: "Observed Availability",
1974	value: availabilityLabel(snapshot.availabilityResult?.status),	2099	value: snapshot.availabilityResult?.status == .unknown ? "No direct registration proof" : "Status collected",
1975	tone: availabilityTone(snapshot.availabilityResult?.status)	2100	tone: .secondary
1976	),	2101	),
1977	at: 1	2102	at: 1
1978	)	2103	)
		2104	rows.insert(
		2105	InfoRowViewData(
		2106	label: "Inference",
		2107	value: availabilityInference(from: snapshot),
		2108	tone: availabilityTone(snapshot.availabilityResult?.status)
		2109	),
		2110	at: 2
		2111	)
		2112	if let confidence = snapshot.availabilityConfidence {
		2113	rows.insert(
		2114	InfoRowViewData(label: "Confidence", value: confidence.title, tone: .secondary),
		2115	at: 3
		2116	)
		2117	}
1979	if let certificateStatus = certificateBadgeLabel(from: snapshot) {	2118	if let certificateStatus = certificateBadgeLabel(from: snapshot) {
1980	rows.insert(	2119	rows.insert(
1981	InfoRowViewData(	2120	InfoRowViewData(
	@@ -1994,6 +2133,7 @@ final class DomainViewModel {
1994	DomainSuggestionViewData(	2133	DomainSuggestionViewData(
1995	id: $0.id,	2134	id: $0.id,
1996	domain: $0.domain,	2135	domain: $0.domain,
		2136	availabilityStatus: $0.status,
1997	status: availabilityLabel($0.status),	2137	status: availabilityLabel($0.status),
1998	tone: availabilityTone($0.status)	2138	tone: availabilityTone($0.status)
1999	)	2139	)
	@@ -2562,6 +2702,17 @@ final class DomainViewModel {
2562	}	2702	}
2563	}	2703	}
2564		2704
		2705	private static func availabilityInference(from snapshot: LookupSnapshot) -> String {
		2706	switch snapshot.availabilityResult?.status {
		2707	case .registered:
		2708	return "Likely registered"
		2709	case .available:
		2710	return "Possibly available"
		2711	case .unknown, .none:
		2712	return "Unclear"
		2713	}
		2714	}
		2715
2565	private static func availabilityTone(_ status: DomainAvailabilityStatus?) -> ResultTone {	2716	private static func availabilityTone(_ status: DomainAvailabilityStatus?) -> ResultTone {
2566	switch status {	2717	switch status {
2567	case .available:	2718	case .available:

DomainDig/HistoryView.swift +101 −11

                                     HStack(spacing: 8) {
                                         AppStatusBadgeView(model: AppStatusFactory.availability(entry.availabilityResult?.status))
                                         AppStatusBadgeView(model: AppStatusFactory.tls(sslInfo: entry.sslInfo, error: entry.sslError))
+                                        if entry.isPartialSnapshot {
+                                            AppStatusBadgeView(model: .init(title: "Partial", systemImage: "exclamationmark.triangle.fill", foregroundColor: .yellow, backgroundColor: .yellow.opacity(0.16)))
+                                        }
                                     }
                                     HStack(spacing: 8) {
                                     }
                                     .font(appDensity.font(.caption2))
                                     .foregroundStyle(.secondary)
+                                    if let note = entry.note, !note.isEmpty {
+                                        Text(note)
+                                            .font(appDensity.font(.caption2))
+                                            .foregroundStyle(.secondary)
+                                            .lineLimit(1)
+                                    }
                                 }
                             }
                             .swipeActions(edge: .trailing, allowsFullSwipe: true) {
     @Bindable var viewModel: DomainViewModel
     let entry: HistoryEntry
     @Environment(\.dismiss) private var dismiss
+    @State private var noteDraft = ""
+    @State private var isEditingNote = false
+    @State private var showRerunOptions = false
     private let dateFormatter: DateFormatter = {
         let formatter = DateFormatter()
                     showSuggestions: entry.availabilityResult?.status == .registered && !entry.suggestions.isEmpty,
                     availabilityLoading: false,
                     suggestionsLoading: false,
+                    provenance: snapshot.provenanceBySection[.availability],
+                    confidence: snapshot.availabilityConfidence,
+                    snapshotNote: entry.note,
                     trackedDomain: viewModel.trackedDomains.first(where: { $0.domain.lowercased() == entry.domain.lowercased() }),
                     trackingLimitMessage: nil,
                     onTrack: {
                     rows: DomainViewModel.ownershipRows(from: snapshot),
                     loading: false,
                     error: snapshot.ownershipError,
+                    provenance: snapshot.provenanceBySection[.ownership],
+                    confidence: snapshot.ownershipConfidence,
                     showsHistoryPlaceholder: !DataAccessService.hasAccess(to: .ownershipHistory)
                 )
                 .padding(.top, appDensity.metrics.sectionSpacing)
                     rows: DomainViewModel.subdomainRows(from: snapshot),
                     loading: false,
                     error: snapshot.subdomainsError,
+                    provenance: snapshot.provenanceBySection[.subdomains],
+                    confidence: snapshot.subdomainConfidence,
                     showsExtendedPlaceholder: !DataAccessService.hasAccess(to: .extendedSubdomains)
                 )
                 .padding(.top, appDensity.metrics.sectionSpacing)
                     DomainDiffView(
                         title: "Compared With Previous Snapshot",
                         sections: DomainDiffService.diff(from: comparisonSnapshot, to: snapshot),
+                        contextNote: DomainDiffService.comparisonContextNote(from: comparisonSnapshot, to: snapshot),
                         showsUnchanged: false
                     )
                     .padding(.top, appDensity.metrics.sectionSpacing)
                     sections: DomainViewModel.dnsRows(from: snapshot),
                     ptrMessage: DomainViewModel.ptrMessage(from: snapshot),
                     loading: false,
+                    dnsProvenance: snapshot.provenanceBySection[.dns],
+                    ptrProvenance: snapshot.provenanceBySection[.ptr],
                     sectionError: snapshot.dnsError
                 )
                 .padding(.top, appDensity.metrics.sectionSpacing)
                     sslInfo: snapshot.sslInfo,
                     sslLoading: false,
                     sslError: snapshot.sslError,
+                    tlsProvenance: snapshot.provenanceBySection[.ssl],
                     responseRows: DomainViewModel.webResponseRows(from: snapshot),
                     headers: snapshot.httpHeaders,
                     headersLoading: false,
                     headersError: snapshot.httpHeadersError,
+                    httpProvenance: snapshot.provenanceBySection[.httpHeaders],
                     redirects: DomainViewModel.redirectRows(from: snapshot),
                     redirectLoading: false,
                     redirectError: snapshot.redirectChainError,
+                    redirectProvenance: snapshot.provenanceBySection[.redirectChain],
                     finalURL: snapshot.redirectChain.last?.url
                 )
                 .padding(.top, appDensity.metrics.sectionSpacing)
                     isCollapsed: .constant(false),
                     rows: DomainViewModel.emailRows(from: snapshot),
                     loading: false,
+                    provenance: snapshot.provenanceBySection[.emailSecurity],
+                    confidence: snapshot.emailSecurityConfidence,
                     error: snapshot.emailSecurityError
                 )
                 .padding(.top, appDensity.metrics.sectionSpacing)
                     reachabilityRows: DomainViewModel.reachabilityRows(from: snapshot),
                     reachabilityLoading: false,
                     reachabilityError: snapshot.reachabilityError,
+                    reachabilityProvenance: snapshot.provenanceBySection[.reachability],
                     locationRows: DomainViewModel.locationRows(from: snapshot),
                     geolocation: snapshot.ipGeolocation,
                     geolocationLoading: false,
                     geolocationError: snapshot.ipGeolocationError,
+                    geolocationProvenance: snapshot.provenanceBySection[.ipGeolocation],
+                    geolocationConfidence: snapshot.geolocationConfidence,
                     standardPortRows: DomainViewModel.portRows(from: snapshot, kind: .standard),
                     customPortRows: DomainViewModel.portRows(from: snapshot, kind: .custom),
                     portScanLoading: false,
                     portScanError: snapshot.portScanError,
+                    portScanProvenance: snapshot.provenanceBySection[.portScan],
                     customPortScanLoading: false,
                     customPortScanError: nil,
                     isCloudflareProxied: snapshot.httpHeaders.contains(where: { $0.name.lowercased() == "cf-ray" }),
         .background(Color.black)
         .navigationTitle(entry.domain)
         .toolbar {
-            Button("Re-run") {
+            ToolbarItemGroup(placement: .topBarTrailing) {
-                viewModel.rerunLookup(from: entry)
+                Button("Note") {
+                    noteDraft = entry.note ?? ""
+                    isEditingNote = true
+                }
+                Button("Re-run") {
+                    showRerunOptions = true
+                }
             }
         }
         .onChange(of: viewModel.rerunNavigationToken) { _, _ in
             dismiss()
         }
+        .confirmationDialog("Re-run lookup", isPresented: $showRerunOptions) {
+            Button("Run with Current Settings") {
+                viewModel.rerunLookup(from: entry, useSnapshotResolver: false)
+            }
+            Button("Run with Snapshot Resolver") {
+                viewModel.rerunLookup(from: entry, useSnapshotResolver: true)
+            }
+            Button("Cancel", role: .cancel) {}
+        } message: {
+            Text(viewModel.resolverMismatchNote(for: entry) ?? "Choose how to reproduce this snapshot.")
+        }
+        .sheet(isPresented: $isEditingNote) {
+            NavigationStack {
+                Form {
+                    Section("Audit Note") {
+                        TextField("Optional note", text: $noteDraft, axis: .vertical)
+                            .lineLimit(3...6)
+                    }
+                }
+                .navigationTitle(entry.domain)
+                .toolbar {
+                    ToolbarItem(placement: .cancellationAction) {
+                        Button("Cancel") {
+                            isEditingNote = false
+                        }
+                    }
+                    ToolbarItem(placement: .confirmationAction) {
+                        Button("Save") {
+                            viewModel.updateHistoryNote(noteDraft, for: entry)
+                            isEditingNote = false
+                        }
+                    }
+                }
+            }
+        }
         .preferredColorScheme(.dark)
     }
     private var snapshotBanner: some View {
-        HStack(spacing: 8) {
+        VStack(alignment: .leading, spacing: 8) {
-            Image(systemName: "archivebox")
+            HStack(spacing: 8) {
-                .font(.caption)
+                Image(systemName: "archivebox")
-            Text("Snapshot from \(dateFormatter.string(from: entry.timestamp))")
+                    .font(.caption)
-                .font(appDensity.font(.caption))
+                Text("Snapshot from \(dateFormatter.string(from: entry.timestamp))")
-            Spacer()
+                    .font(appDensity.font(.caption))
-            Text("Live re-run available")
+                Spacer()
-                .font(appDensity.font(.caption2))
+                Text("Live re-run available")
-                .foregroundStyle(.secondary)
+                    .font(appDensity.font(.caption2))
+                    .foregroundStyle(.secondary)
+            }
+            if let mismatchNote = viewModel.resolverMismatchNote(for: entry) {
+                Text(mismatchNote)
+                    .font(appDensity.font(.caption2))
+                    .foregroundStyle(.orange)
+            }
+            if entry.isPartialSnapshot {
+                Text("Partial snapshot: \(entry.validationIssues.joined(separator: " | "))")
+                    .font(appDensity.font(.caption2))
+                    .foregroundStyle(.yellow)
+            }
+            if let note = entry.note, !note.isEmpty {
+                Text(note)
+                    .font(appDensity.font(.caption2))
+                    .foregroundStyle(.secondary)
+            }
         }
         .foregroundStyle(.secondary)
         .padding(8)

DomainDig/LookupRuntime.swift +3 −9

     }
     func availability(domain: String) async -> CachedLookupResult<DomainAvailabilityResult> {
-        await execute(
+        CachedLookupResult(
-            key: .domain(domain, .availability),
+            value: await DomainAvailabilityService.check(domain: domain),
-            extract: { payload in
+            source: .live
-                guard case let .availability(result) = payload else { return nil }
-                return result
-            },
-            operation: {
-                .availability(await DomainAvailabilityService.check(domain: domain))
-            }
         )
     }

DomainDig/Models.swift +130 −8

	@@ -6,6 +6,59 @@ enum ServiceResult<Value> {
6	case error(String)	6	case error(String)
7	}	7	}
8		8
		9	enum ConfidenceLevel: String, Codable {
		10	case high
		11	case medium
		12	case low
		13
		14	var title: String {
		15	rawValue.capitalized
		16	}
		17	}
		18
		19	enum InspectionErrorKind: String, Codable {
		20	case network
		21	case timeout
		22	case rateLimited
		23	case parsing
		24	case unsupported
		25	case unavailable
		26	case unknown
		27
		28	var title: String {
		29	switch self {
		30	case .network:
		31	return "Network"
		32	case .timeout:
		33	return "Timeout"
		34	case .rateLimited:
		35	return "Rate limited"
		36	case .parsing:
		37	return "Parsing"
		38	case .unsupported:
		39	return "Unsupported"
		40	case .unavailable:
		41	return "Unavailable"
		42	case .unknown:
		43	return "Unknown"
		44	}
		45	}
		46	}
		47
		48	struct InspectionFailure: Codable, Equatable {
		49	let kind: InspectionErrorKind
		50	let message: String
		51	let details: String?
		52	}
		53
		54	struct SectionProvenance: Codable, Equatable {
		55	let source: String
		56	let collectedAt: Date
		57	let provider: String?
		58	let resolver: String?
		59	let resultSource: LookupResultSource
		60	}
		61
9	enum LookupResultSource: String, Codable {	62	enum LookupResultSource: String, Codable {
10	case live	63	case live
11	case cached	64	case cached
	@@ -129,19 +182,28 @@ struct DomainChangeSummary: Codable, Equatable {
129	let message: String	182	let message: String
130	let severity: ChangeSeverity	183	let severity: ChangeSeverity
131	let generatedAt: Date	184	let generatedAt: Date
		185	let observedFacts: [String]
		186	let inferredConclusions: [String]
		187	let contextNote: String?
132		188
133	init(	189	init(
134	hasChanges: Bool,	190	hasChanges: Bool,
135	changedSections: [String],	191	changedSections: [String],
136	message: String,	192	message: String,
137	severity: ChangeSeverity,	193	severity: ChangeSeverity,
138	generatedAt: Date	194	generatedAt: Date,
		195	observedFacts: [String] = [],
		196	inferredConclusions: [String] = [],
		197	contextNote: String? = nil
139	) {	198	) {
140	self.hasChanges = hasChanges	199	self.hasChanges = hasChanges
141	self.changedSections = changedSections	200	self.changedSections = changedSections
142	self.message = message	201	self.message = message
143	self.severity = severity	202	self.severity = severity
144	self.generatedAt = generatedAt	203	self.generatedAt = generatedAt
		204	self.observedFacts = observedFacts
		205	self.inferredConclusions = inferredConclusions
		206	self.contextNote = contextNote
145	}	207	}
146		208
147	init(from decoder: Decoder) throws {	209	init(from decoder: Decoder) throws {
	@@ -152,6 +214,9 @@ struct DomainChangeSummary: Codable, Equatable {
152	severity = try container.decodeIfPresent(ChangeSeverity.self, forKey: .severity) ?? (hasChanges ? .medium : .low)	214	severity = try container.decodeIfPresent(ChangeSeverity.self, forKey: .severity) ?? (hasChanges ? .medium : .low)
153	message = try container.decodeIfPresent(String.self, forKey: .message)	215	message = try container.decodeIfPresent(String.self, forKey: .message)
154	?? (changedSections.isEmpty ? "No meaningful changes" : changedSections.joined(separator: " • "))	216	?? (changedSections.isEmpty ? "No meaningful changes" : changedSections.joined(separator: " • "))
		217	observedFacts = try container.decodeIfPresent([String].self, forKey: .observedFacts) ?? []
		218	inferredConclusions = try container.decodeIfPresent([String].self, forKey: .inferredConclusions) ?? []
		219	contextNote = try container.decodeIfPresent(String.self, forKey: .contextNote)
155	}	220	}
156	}	221	}
157		222
	@@ -709,6 +774,7 @@ struct HistoryEntry: Identifiable, Codable {
709	let domain: String	774	let domain: String
710	let timestamp: Date	775	let timestamp: Date
711	var trackedDomainID: UUID?	776	var trackedDomainID: UUID?
		777	var note: String?
712	let dnsSections: [DNSSection]	778	let dnsSections: [DNSSection]
713	let sslInfo: SSLCertificateInfo?	779	let sslInfo: SSLCertificateInfo?
714	let httpHeaders: [HTTPHeader]	780	let httpHeaders: [HTTPHeader]
	@@ -724,6 +790,18 @@ struct HistoryEntry: Identifiable, Codable {
724	var hstsPreloaded: Bool?	790	var hstsPreloaded: Bool?
725	var availabilityResult: DomainAvailabilityResult?	791	var availabilityResult: DomainAvailabilityResult?
726	var suggestions: [DomainSuggestionResult]	792	var suggestions: [DomainSuggestionResult]
		793	var appVersion: String
		794	var resultSource: LookupResultSource
		795	var dataSources: [String]
		796	var provenanceBySection: [LookupSectionKind: SectionProvenance]
		797	var availabilityConfidence: ConfidenceLevel?
		798	var ownershipConfidence: ConfidenceLevel?
		799	var subdomainConfidence: ConfidenceLevel?
		800	var emailSecurityConfidence: ConfidenceLevel?
		801	var geolocationConfidence: ConfidenceLevel?
		802	var errorDetails: [LookupSectionKind: InspectionFailure]
		803	var isPartialSnapshot: Bool
		804	var validationIssues: [String]
727	var resolverDisplayName: String	805	var resolverDisplayName: String
728	var resolverURLString: String	806	var resolverURLString: String
729	var totalLookupDurationMs: Int?	807	var totalLookupDurationMs: Int?
	@@ -744,14 +822,21 @@ struct HistoryEntry: Identifiable, Codable {
744	var subdomainsError: String?	822	var subdomainsError: String?
745	var portScanError: String?	823	var portScanError: String?
746		824
747	init(domain: String, timestamp: Date, trackedDomainID: UUID? = nil, dnsSections: [DNSSection],	825	init(domain: String, timestamp: Date, trackedDomainID: UUID? = nil, note: String? = nil, dnsSections: [DNSSection],
748	sslInfo: SSLCertificateInfo?, httpHeaders: [HTTPHeader],	826	sslInfo: SSLCertificateInfo?, httpHeaders: [HTTPHeader],
749	reachabilityResults: [PortReachability], ipGeolocation: IPGeolocation?,	827	reachabilityResults: [PortReachability], ipGeolocation: IPGeolocation?,
750	emailSecurity: EmailSecurityResult? = nil, mtaSts: MTASTSResult? = nil, ownership: DomainOwnership? = nil,	828	emailSecurity: EmailSecurityResult? = nil, mtaSts: MTASTSResult? = nil, ownership: DomainOwnership? = nil,
751	ptrRecord: String? = nil, redirectChain: [RedirectHop] = [], subdomains: [DiscoveredSubdomain] = [],	829	ptrRecord: String? = nil, redirectChain: [RedirectHop] = [], subdomains: [DiscoveredSubdomain] = [],
752	portScanResults: [PortScanResult] = [],	830	portScanResults: [PortScanResult] = [],
753	hstsPreloaded: Bool? = nil, availabilityResult: DomainAvailabilityResult? = nil,	831	hstsPreloaded: Bool? = nil, availabilityResult: DomainAvailabilityResult? = nil,
754	suggestions: [DomainSuggestionResult] = [], resolverDisplayName: String, resolverURLString: String,	832	suggestions: [DomainSuggestionResult] = [], appVersion: String = "2.7.0",
		833	resultSource: LookupResultSource = .snapshot, dataSources: [String] = [],
		834	provenanceBySection: [LookupSectionKind: SectionProvenance] = [:],
		835	availabilityConfidence: ConfidenceLevel? = nil, ownershipConfidence: ConfidenceLevel? = nil,
		836	subdomainConfidence: ConfidenceLevel? = nil, emailSecurityConfidence: ConfidenceLevel? = nil,
		837	geolocationConfidence: ConfidenceLevel? = nil,
		838	errorDetails: [LookupSectionKind: InspectionFailure] = [:], isPartialSnapshot: Bool = false,
		839	validationIssues: [String] = [], resolverDisplayName: String, resolverURLString: String,
755	totalLookupDurationMs: Int? = nil, primaryIP: String? = nil, finalRedirectURL: String? = nil,	840	totalLookupDurationMs: Int? = nil, primaryIP: String? = nil, finalRedirectURL: String? = nil,
756	tlsStatusSummary: String? = nil, emailSecuritySummary: String? = nil, httpGradeSummary: String? = nil,	841	tlsStatusSummary: String? = nil, emailSecuritySummary: String? = nil, httpGradeSummary: String? = nil,
757	changeSummary: DomainChangeSummary? = nil, sslError: String? = nil, httpHeadersError: String? = nil,	842	changeSummary: DomainChangeSummary? = nil, sslError: String? = nil, httpHeadersError: String? = nil,
	@@ -761,6 +846,7 @@ struct HistoryEntry: Identifiable, Codable {
761	self.domain = domain	846	self.domain = domain
762	self.timestamp = timestamp	847	self.timestamp = timestamp
763	self.trackedDomainID = trackedDomainID	848	self.trackedDomainID = trackedDomainID
		849	self.note = note
764	self.dnsSections = dnsSections	850	self.dnsSections = dnsSections
765	self.sslInfo = sslInfo	851	self.sslInfo = sslInfo
766	self.httpHeaders = httpHeaders	852	self.httpHeaders = httpHeaders
	@@ -776,6 +862,18 @@ struct HistoryEntry: Identifiable, Codable {
776	self.hstsPreloaded = hstsPreloaded	862	self.hstsPreloaded = hstsPreloaded
777	self.availabilityResult = availabilityResult	863	self.availabilityResult = availabilityResult
778	self.suggestions = suggestions	864	self.suggestions = suggestions
		865	self.appVersion = appVersion
		866	self.resultSource = resultSource
		867	self.dataSources = dataSources
		868	self.provenanceBySection = provenanceBySection
		869	self.availabilityConfidence = availabilityConfidence
		870	self.ownershipConfidence = ownershipConfidence
		871	self.subdomainConfidence = subdomainConfidence
		872	self.emailSecurityConfidence = emailSecurityConfidence
		873	self.geolocationConfidence = geolocationConfidence
		874	self.errorDetails = errorDetails
		875	self.isPartialSnapshot = isPartialSnapshot
		876	self.validationIssues = validationIssues
779	self.resolverDisplayName = resolverDisplayName	877	self.resolverDisplayName = resolverDisplayName
780	self.resolverURLString = resolverURLString	878	self.resolverURLString = resolverURLString
781	self.totalLookupDurationMs = totalLookupDurationMs	879	self.totalLookupDurationMs = totalLookupDurationMs
	@@ -800,13 +898,14 @@ struct HistoryEntry: Identifiable, Codable {
800	init(from decoder: Decoder) throws {	898	init(from decoder: Decoder) throws {
801	let container = try decoder.container(keyedBy: CodingKeys.self)	899	let container = try decoder.container(keyedBy: CodingKeys.self)
802	id = try container.decodeIfPresent(UUID.self, forKey: .id) ?? UUID()	900	id = try container.decodeIfPresent(UUID.self, forKey: .id) ?? UUID()
803	domain = try container.decode(String.self, forKey: .domain)	901	domain = try container.decodeIfPresent(String.self, forKey: .domain) ?? "unknown-domain"
804	timestamp = try container.decode(Date.self, forKey: .timestamp)	902	timestamp = try container.decodeIfPresent(Date.self, forKey: .timestamp) ?? .distantPast
805	trackedDomainID = try container.decodeIfPresent(UUID.self, forKey: .trackedDomainID)	903	trackedDomainID = try container.decodeIfPresent(UUID.self, forKey: .trackedDomainID)
806	dnsSections = try container.decode([DNSSection].self, forKey: .dnsSections)	904	note = try container.decodeIfPresent(String.self, forKey: .note)
		905	dnsSections = try container.decodeIfPresent([DNSSection].self, forKey: .dnsSections) ?? []
807	sslInfo = try container.decodeIfPresent(SSLCertificateInfo.self, forKey: .sslInfo)	906	sslInfo = try container.decodeIfPresent(SSLCertificateInfo.self, forKey: .sslInfo)
808	httpHeaders = try container.decode([HTTPHeader].self, forKey: .httpHeaders)	907	httpHeaders = try container.decodeIfPresent([HTTPHeader].self, forKey: .httpHeaders) ?? []
809	reachabilityResults = try container.decode([PortReachability].self, forKey: .reachabilityResults)	908	reachabilityResults = try container.decodeIfPresent([PortReachability].self, forKey: .reachabilityResults) ?? []
810	ipGeolocation = try container.decodeIfPresent(IPGeolocation.self, forKey: .ipGeolocation)	909	ipGeolocation = try container.decodeIfPresent(IPGeolocation.self, forKey: .ipGeolocation)
811	emailSecurity = try container.decodeIfPresent(EmailSecurityResult.self, forKey: .emailSecurity)	910	emailSecurity = try container.decodeIfPresent(EmailSecurityResult.self, forKey: .emailSecurity)
812	mtaSts = try container.decodeIfPresent(MTASTSResult.self, forKey: .mtaSts) ?? emailSecurity?.mtaSts	911	mtaSts = try container.decodeIfPresent(MTASTSResult.self, forKey: .mtaSts) ?? emailSecurity?.mtaSts
	@@ -818,6 +917,18 @@ struct HistoryEntry: Identifiable, Codable {
818	hstsPreloaded = try container.decodeIfPresent(Bool.self, forKey: .hstsPreloaded)	917	hstsPreloaded = try container.decodeIfPresent(Bool.self, forKey: .hstsPreloaded)
819	availabilityResult = try container.decodeIfPresent(DomainAvailabilityResult.self, forKey: .availabilityResult)	918	availabilityResult = try container.decodeIfPresent(DomainAvailabilityResult.self, forKey: .availabilityResult)
820	suggestions = try container.decodeIfPresent([DomainSuggestionResult].self, forKey: .suggestions) ?? []	919	suggestions = try container.decodeIfPresent([DomainSuggestionResult].self, forKey: .suggestions) ?? []
		920	appVersion = try container.decodeIfPresent(String.self, forKey: .appVersion) ?? "2.6.0"
		921	resultSource = try container.decodeIfPresent(LookupResultSource.self, forKey: .resultSource) ?? .snapshot
		922	dataSources = try container.decodeIfPresent([String].self, forKey: .dataSources) ?? []
		923	provenanceBySection = try container.decodeIfPresent([LookupSectionKind: SectionProvenance].self, forKey: .provenanceBySection) ?? [:]
		924	availabilityConfidence = try container.decodeIfPresent(ConfidenceLevel.self, forKey: .availabilityConfidence)
		925	ownershipConfidence = try container.decodeIfPresent(ConfidenceLevel.self, forKey: .ownershipConfidence)
		926	subdomainConfidence = try container.decodeIfPresent(ConfidenceLevel.self, forKey: .subdomainConfidence)
		927	emailSecurityConfidence = try container.decodeIfPresent(ConfidenceLevel.self, forKey: .emailSecurityConfidence)
		928	geolocationConfidence = try container.decodeIfPresent(ConfidenceLevel.self, forKey: .geolocationConfidence)
		929	errorDetails = try container.decodeIfPresent([LookupSectionKind: InspectionFailure].self, forKey: .errorDetails) ?? [:]
		930	validationIssues = try container.decodeIfPresent([String].self, forKey: .validationIssues) ?? HistoryEntry.defaultValidationIssues(domain: domain, timestamp: timestamp)
		931	isPartialSnapshot = try container.decodeIfPresent(Bool.self, forKey: .isPartialSnapshot) ?? !validationIssues.isEmpty
821	resolverDisplayName = try container.decodeIfPresent(String.self, forKey: .resolverDisplayName) ?? "Cloudflare"	932	resolverDisplayName = try container.decodeIfPresent(String.self, forKey: .resolverDisplayName) ?? "Cloudflare"
822	resolverURLString = try container.decodeIfPresent(String.self, forKey: .resolverURLString) ?? DNSResolverOption.defaultURLString	933	resolverURLString = try container.decodeIfPresent(String.self, forKey: .resolverURLString) ?? DNSResolverOption.defaultURLString
823	totalLookupDurationMs = try container.decodeIfPresent(Int.self, forKey: .totalLookupDurationMs)	934	totalLookupDurationMs = try container.decodeIfPresent(Int.self, forKey: .totalLookupDurationMs)
	@@ -838,6 +949,17 @@ struct HistoryEntry: Identifiable, Codable {
838	subdomainsError = try container.decodeIfPresent(String.self, forKey: .subdomainsError)	949	subdomainsError = try container.decodeIfPresent(String.self, forKey: .subdomainsError)
839	portScanError = try container.decodeIfPresent(String.self, forKey: .portScanError)	950	portScanError = try container.decodeIfPresent(String.self, forKey: .portScanError)
840	}	951	}
		952
		953	private static func defaultValidationIssues(domain: String, timestamp: Date) -> [String] {
		954	var issues: [String] = []
		955	if domain == "unknown-domain" {
		956	issues.append("Missing domain in stored snapshot")
		957	}
		958	if timestamp == .distantPast {
		959	issues.append("Missing collection timestamp in stored snapshot")
		960	}
		961	return issues
		962	}
841	}	963	}
842		964
843	// MARK: - Cloudflare DNS-over-HTTPS Response	965	// MARK: - Cloudflare DNS-over-HTTPS Response

DomainDig/WatchlistView.swift +23 −2

     @State private var noteDraft = ""
     @State private var isEditingNote = false
+    @State private var showRerunOptions = false
     private var liveTrackedDomain: TrackedDomain {
         viewModel.trackedDomains.first(where: { $0.id == trackedDomain.id }) ?? trackedDomain
                 }
                 Button {
-                    viewModel.rerunInspection(for: liveTrackedDomain)
+                    showRerunOptions = true
                 } label: {
                     Label("Re-run Inspection", systemImage: "magnifyingglass")
                 }
             if !latestDiffSections.isEmpty {
                 Section("Latest Diff") {
-                    DomainDiffView(title: "Latest Snapshot vs Previous", sections: latestDiffSections, showsUnchanged: false)
+                    DomainDiffView(
+                        title: "Latest Snapshot vs Previous",
+                        sections: latestDiffSections,
+                        contextNote: latestSnapshots.count >= 2
+                            ? DomainDiffService.comparisonContextNote(from: latestSnapshots[1].snapshot, to: latestSnapshots[0].snapshot)
+                            : nil,
+                        showsUnchanged: false
+                    )
                 }
                 .listRowBackground(Color.clear)
             }
         .onChange(of: viewModel.rerunNavigationToken) { _, _ in
             dismiss()
         }
+        .confirmationDialog("Re-run inspection", isPresented: $showRerunOptions) {
+            Button("Run with Current Settings") {
+                viewModel.rerunInspection(for: liveTrackedDomain, useSnapshotResolver: false)
+            }
+            if latestSnapshots.first != nil {
+                Button("Run with Snapshot Resolver") {
+                    viewModel.rerunInspection(for: liveTrackedDomain, useSnapshotResolver: true)
+                }
+            }
+            Button("Cancel", role: .cancel) {}
+        } message: {
+            Text(viewModel.resolverMismatchNote(for: liveTrackedDomain) ?? "Choose how to reproduce the most recent snapshot.")
+        }
         .sheet(isPresented: $isEditingNote) {
             NavigationStack {
                 Form {

DomainInspectionService.swift +315 −32

	@@ -20,6 +20,9 @@ struct DomainInspectionService {
20	let resolverURLString = DNSLookupService.currentResolverURLString()	20	let resolverURLString = DNSLookupService.currentResolverURLString()
21	var cachedSections = Set<LookupSectionKind>()	21	var cachedSections = Set<LookupSectionKind>()
22	var sectionSources: [LookupResultSource] = []	22	var sectionSources: [LookupResultSource] = []
		23	var provenanceBySection: [LookupSectionKind: SectionProvenance] = [:]
		24	var dataSources = Set<String>()
		25	var errorDetails: [LookupSectionKind: InspectionFailure] = [:]
23		26
24	async let dnsFetch = runtime.dns(domain: normalizedDomain)	27	async let dnsFetch = runtime.dns(domain: normalizedDomain)
25	async let availabilityFetch = runtime.availability(domain: normalizedDomain)	28	async let availabilityFetch = runtime.availability(domain: normalizedDomain)
	@@ -34,41 +37,129 @@ struct DomainInspectionService {
34		37
35	let resolvedDNS = await dnsFetch	38	let resolvedDNS = await dnsFetch
36	let dnsResult = normalizeErrors(in: resolvedDNS.value)	39	let dnsResult = normalizeErrors(in: resolvedDNS.value)
37	track(.dns, source: resolvedDNS.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	40	track(
		41	.dns,
		42	source: resolvedDNS.source,
		43	provenance: provenance(for: .dns, source: resolvedDNS.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		44	cachedSections: &cachedSections,
		45	sectionSources: &sectionSources,
		46	provenanceBySection: &provenanceBySection,
		47	dataSources: &dataSources
		48	)
		49	captureFailure(for: .dns, result: dnsResult, into: &errorDetails)
38		50
39	let availability = await availabilityFetch	51	let availability = await availabilityFetch
40	track(.availability, source: availability.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	52	track(
		53	.availability,
		54	source: availability.source,
		55	provenance: provenance(for: .availability, source: availability.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		56	cachedSections: &cachedSections,
		57	sectionSources: &sectionSources,
		58	provenanceBySection: &provenanceBySection,
		59	dataSources: &dataSources
		60	)
41		61
42	let resolvedSSL = await sslFetch	62	let resolvedSSL = await sslFetch
43	let sslResult = normalizeErrors(in: resolvedSSL.value)	63	let sslResult = normalizeErrors(in: resolvedSSL.value)
44	track(.ssl, source: resolvedSSL.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	64	track(
		65	.ssl,
		66	source: resolvedSSL.source,
		67	provenance: provenance(for: .ssl, source: resolvedSSL.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		68	cachedSections: &cachedSections,
		69	sectionSources: &sectionSources,
		70	provenanceBySection: &provenanceBySection,
		71	dataSources: &dataSources
		72	)
		73	captureFailure(for: .ssl, result: sslResult, into: &errorDetails)
45		74
46	let hsts = await hstsFetch	75	let hsts = await hstsFetch
47	track(.hsts, source: hsts.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	76	track(
		77	.hsts,
		78	source: hsts.source,
		79	provenance: provenance(for: .hsts, source: hsts.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		80	cachedSections: &cachedSections,
		81	sectionSources: &sectionSources,
		82	provenanceBySection: &provenanceBySection,
		83	dataSources: &dataSources
		84	)
48		85
49	let http = await httpFetch	86	let http = await httpFetch
50	let httpResult = normalizeErrors(in: http.value)	87	let httpResult = normalizeErrors(in: http.value)
51	track(.httpHeaders, source: http.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	88	track(
		89	.httpHeaders,
		90	source: http.source,
		91	provenance: provenance(for: .httpHeaders, source: http.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		92	cachedSections: &cachedSections,
		93	sectionSources: &sectionSources,
		94	provenanceBySection: &provenanceBySection,
		95	dataSources: &dataSources
		96	)
		97	captureFailure(for: .httpHeaders, result: httpResult, into: &errorDetails)
52		98
53	let reachability = await reachabilityFetch	99	let reachability = await reachabilityFetch
54	let reachabilityResult = normalizeErrors(in: reachability.value)	100	let reachabilityResult = normalizeErrors(in: reachability.value)
55	track(.reachability, source: reachability.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	101	track(
		102	.reachability,
		103	source: reachability.source,
		104	provenance: provenance(for: .reachability, source: reachability.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		105	cachedSections: &cachedSections,
		106	sectionSources: &sectionSources,
		107	provenanceBySection: &provenanceBySection,
		108	dataSources: &dataSources
		109	)
		110	captureFailure(for: .reachability, result: reachabilityResult, into: &errorDetails)
56		111
57	let resolvedOwnership = await ownershipFetch	112	let resolvedOwnership = await ownershipFetch
58	let ownershipResult = normalizeErrors(in: resolvedOwnership.value)	113	let ownershipResult = normalizeErrors(in: resolvedOwnership.value)
59	track(.ownership, source: resolvedOwnership.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	114	track(
		115	.ownership,
		116	source: resolvedOwnership.source,
		117	provenance: provenance(for: .ownership, source: resolvedOwnership.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		118	cachedSections: &cachedSections,
		119	sectionSources: &sectionSources,
		120	provenanceBySection: &provenanceBySection,
		121	dataSources: &dataSources
		122	)
		123	captureFailure(for: .ownership, result: ownershipResult, into: &errorDetails)
60		124
61	let redirects = await redirectFetch	125	let redirects = await redirectFetch
62	let redirectResult = normalizeErrors(in: redirects.value)	126	let redirectResult = normalizeErrors(in: redirects.value)
63	track(.redirectChain, source: redirects.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	127	track(
		128	.redirectChain,
		129	source: redirects.source,
		130	provenance: provenance(for: .redirectChain, source: redirects.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		131	cachedSections: &cachedSections,
		132	sectionSources: &sectionSources,
		133	provenanceBySection: &provenanceBySection,
		134	dataSources: &dataSources
		135	)
		136	captureFailure(for: .redirectChain, result: redirectResult, into: &errorDetails)
64		137
65	let resolvedSubdomains = await subdomainFetch	138	let resolvedSubdomains = await subdomainFetch
66	let subdomainResult = normalizeErrors(in: resolvedSubdomains.value)	139	let subdomainResult = normalizeErrors(in: resolvedSubdomains.value)
67	track(.subdomains, source: resolvedSubdomains.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	140	track(
		141	.subdomains,
		142	source: resolvedSubdomains.source,
		143	provenance: provenance(for: .subdomains, source: resolvedSubdomains.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		144	cachedSections: &cachedSections,
		145	sectionSources: &sectionSources,
		146	provenanceBySection: &provenanceBySection,
		147	dataSources: &dataSources
		148	)
		149	captureFailure(for: .subdomains, result: subdomainResult, into: &errorDetails)
68		150
69	let ports = await portScanFetch	151	let ports = await portScanFetch
70	let portScanResult = normalizeErrors(in: ports.value)	152	let portScanResult = normalizeErrors(in: ports.value)
71	track(.portScan, source: ports.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	153	track(
		154	.portScan,
		155	source: ports.source,
		156	provenance: provenance(for: .portScan, source: ports.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		157	cachedSections: &cachedSections,
		158	sectionSources: &sectionSources,
		159	provenanceBySection: &provenanceBySection,
		160	dataSources: &dataSources
		161	)
		162	captureFailure(for: .portScan, result: portScanResult, into: &errorDetails)
72		163
73	let dnsSections = mapServiceResult(dnsResult, emptyValue: [])	164	let dnsSections = mapServiceResult(dnsResult, emptyValue: [])
74	let sslInfo = mapOptionalValueServiceResult(sslResult)	165	let sslInfo = mapOptionalValueServiceResult(sslResult)
	@@ -92,12 +183,30 @@ struct DomainInspectionService {
92	} else {	183	} else {
93	emailOutcome = await runtime.email(domain: normalizedDomain, txtRecords: txtRecords)	184	emailOutcome = await runtime.email(domain: normalizedDomain, txtRecords: txtRecords)
94	}	185	}
95	track(.emailSecurity, source: emailOutcome.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	186	let normalizedEmailResult = normalizeErrors(in: emailOutcome.value)
		187	track(
		188	.emailSecurity,
		189	source: emailOutcome.source,
		190	provenance: provenance(for: .emailSecurity, source: emailOutcome.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		191	cachedSections: &cachedSections,
		192	sectionSources: &sectionSources,
		193	provenanceBySection: &provenanceBySection,
		194	dataSources: &dataSources
		195	)
		196	captureFailure(for: .emailSecurity, result: normalizedEmailResult, into: &errorDetails)
96		197
97	let suggestionsOutcome: CachedLookupResult<[DomainSuggestionResult]>	198	let suggestionsOutcome: CachedLookupResult<[DomainSuggestionResult]>
98	if availability.value.status == .registered {	199	if availability.value.status == .registered {
99	suggestionsOutcome = await runtime.suggestions(domain: normalizedDomain)	200	suggestionsOutcome = await runtime.suggestions(domain: normalizedDomain)
100	track(.suggestions, source: suggestionsOutcome.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	201	track(
		202	.suggestions,
		203	source: suggestionsOutcome.source,
		204	provenance: provenance(for: .suggestions, source: suggestionsOutcome.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		205	cachedSections: &cachedSections,
		206	sectionSources: &sectionSources,
		207	provenanceBySection: &provenanceBySection,
		208	dataSources: &dataSources
		209	)
101	} else {	210	} else {
102	suggestionsOutcome = CachedLookupResult(value: [], source: .live)	211	suggestionsOutcome = CachedLookupResult(value: [], source: .live)
103	}	212	}
	@@ -122,27 +231,65 @@ struct DomainInspectionService {
122	}	231	}
123		232
124	if let ptrOutcome {	233	if let ptrOutcome {
125	track(.ptr, source: ptrOutcome.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	234	let normalizedPTRResult = normalizeErrors(in: ptrOutcome.value)
		235	track(
		236	.ptr,
		237	source: ptrOutcome.source,
		238	provenance: provenance(for: .ptr, source: ptrOutcome.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		239	cachedSections: &cachedSections,
		240	sectionSources: &sectionSources,
		241	provenanceBySection: &provenanceBySection,
		242	dataSources: &dataSources
		243	)
		244	captureFailure(for: .ptr, result: normalizedPTRResult, into: &errorDetails)
126	}	245	}
127	if let geoOutcome {	246	if let geoOutcome {
128	track(.ipGeolocation, source: geoOutcome.source, cachedSections: &cachedSections, sectionSources: &sectionSources)	247	let normalizedGeoResult = normalizeErrors(in: geoOutcome.value)
		248	track(
		249	.ipGeolocation,
		250	source: geoOutcome.source,
		251	provenance: provenance(for: .ipGeolocation, source: geoOutcome.source, collectedAt: Date(), resolverDisplayName: resolverDisplayName),
		252	cachedSections: &cachedSections,
		253	sectionSources: &sectionSources,
		254	provenanceBySection: &provenanceBySection,
		255	dataSources: &dataSources
		256	)
		257	captureFailure(for: .ipGeolocation, result: normalizedGeoResult, into: &errorDetails)
129	}	258	}
130	} else {	259	} else {
131	ptrOutcome = nil	260	ptrOutcome = nil
132	geoOutcome = nil	261	geoOutcome = nil
133	}	262	}
134		263
135	let emailSecurity = mapOptionalValueServiceResult(normalizeErrors(in: emailOutcome.value))	264	let emailSecurity = mapOptionalValueServiceResult(normalizedEmailResult)
136	let ptrRecord = mapOptionalServiceResult(ptrOutcome.map { normalizeErrors(in: $0.value) }, missingMessage: "No A record available")	265	let ptrRecord = mapOptionalServiceResult(ptrOutcome.map { normalizeErrors(in: $0.value) }, missingMessage: "No A record available")
137	let geolocation = mapOptionalServiceResult(geoOutcome.map { normalizeErrors(in: $0.value) }, missingMessage: "No A record available")	266	let geolocation = mapOptionalServiceResult(geoOutcome.map { normalizeErrors(in: $0.value) }, missingMessage: "No A record available")
		267	let availabilityConfidence = confidenceForAvailability(result: availability.value, provenance: provenanceBySection[.availability])
		268	let ownershipConfidence = confidenceForOwnership(result: ownership.value, error: ownership.message)
		269	let subdomainConfidence = confidenceForSubdomains(results: subdomains.value, error: subdomains.message)
		270	let emailConfidence = confidenceForEmail(result: emailSecurity.value, error: emailSecurity.message)
		271	let geolocationConfidence = confidenceForGeolocation(result: geolocation.value, error: geolocation.message)
		272	let validationIssues = validationIssues(for: normalizedDomain, snapshotTimestamp: startedAt, availability: availability.value, dnsSections: dnsSections.value, provenanceBySection: provenanceBySection)
138		273
139	return LookupSnapshot(	274	return LookupSnapshot(
140	historyEntryID: nil,	275	historyEntryID: nil,
141	domain: availability.value.domain,	276	domain: availability.value.domain,
142	timestamp: Date(),	277	timestamp: Date(),
143	trackedDomainID: previousSnapshot?.trackedDomainID,	278	trackedDomainID: previousSnapshot?.trackedDomainID,
		279	note: previousSnapshot?.note,
		280	appVersion: AppVersion.current,
144	resolverDisplayName: resolverDisplayName,	281	resolverDisplayName: resolverDisplayName,
145	resolverURLString: resolverURLString,	282	resolverURLString: resolverURLString,
		283	dataSources: Array(dataSources).sorted(),
		284	provenanceBySection: provenanceBySection,
		285	availabilityConfidence: availabilityConfidence,
		286	ownershipConfidence: ownershipConfidence,
		287	subdomainConfidence: subdomainConfidence,
		288	emailSecurityConfidence: emailConfidence,
		289	geolocationConfidence: geolocationConfidence,
		290	errorDetails: errorDetails,
		291	isPartialSnapshot: !validationIssues.isEmpty,
		292	validationIssues: validationIssues,
146	totalLookupDurationMs: Int(Date().timeIntervalSince(startedAt) * 1000),	293	totalLookupDurationMs: Int(Date().timeIntervalSince(startedAt) * 1000),
147	dnsSections: dnsSections.value,	294	dnsSections: dnsSections.value,
148	dnsError: dnsSections.message,	295	dnsError: dnsSections.message,
	@@ -193,15 +340,64 @@ struct DomainInspectionService {
193	private func track(	340	private func track(
194	_ section: LookupSectionKind,	341	_ section: LookupSectionKind,
195	source: LookupResultSource,	342	source: LookupResultSource,
		343	provenance: SectionProvenance,
196	cachedSections: inout Set<LookupSectionKind>,	344	cachedSections: inout Set<LookupSectionKind>,
197	sectionSources: inout [LookupResultSource]	345	sectionSources: inout [LookupResultSource],
		346	provenanceBySection: inout [LookupSectionKind: SectionProvenance],
		347	dataSources: inout Set<String>
198	) {	348	) {
199	sectionSources.append(source)	349	sectionSources.append(source)
		350	provenanceBySection[section] = provenance
		351	dataSources.insert(provenance.provider ?? provenance.source)
200	if source != .live {	352	if source != .live {
201	cachedSections.insert(section)	353	cachedSections.insert(section)
202	}	354	}
203	}	355	}
204		356
		357	private func provenance(
		358	for section: LookupSectionKind,
		359	source: LookupResultSource,
		360	collectedAt: Date,
		361	resolverDisplayName: String
		362	) -> SectionProvenance {
		363	switch section {
		364	case .dns, .ptr:
		365	return SectionProvenance(
		366	source: "DNS-over-HTTPS query",
		367	collectedAt: collectedAt,
		368	provider: "Selected DoH resolver",
		369	resolver: resolverDisplayName,
		370	resultSource: source
		371	)
		372	case .availability:
		373	return SectionProvenance(
		374	source: "RDAP lookup with DNS fallback",
		375	collectedAt: collectedAt,
		376	provider: "rdap.org / selected resolver",
		377	resolver: resolverDisplayName,
		378	resultSource: source
		379	)
		380	case .ssl:
		381	return SectionProvenance(source: "Direct TLS handshake", collectedAt: collectedAt, provider: "Target host", resolver: nil, resultSource: source)
		382	case .hsts, .httpHeaders, .redirectChain:
		383	return SectionProvenance(source: "HTTP request", collectedAt: collectedAt, provider: "Target host", resolver: nil, resultSource: source)
		384	case .reachability:
		385	return SectionProvenance(source: "TCP reachability probe", collectedAt: collectedAt, provider: "Target host", resolver: nil, resultSource: source)
		386	case .ipGeolocation:
		387	return SectionProvenance(source: "IP geolocation lookup", collectedAt: collectedAt, provider: "ipapi.co", resolver: nil, resultSource: source)
		388	case .emailSecurity:
		389	return SectionProvenance(source: "DNS TXT inspection", collectedAt: collectedAt, provider: "Selected DoH resolver", resolver: resolverDisplayName, resultSource: source)
		390	case .ownership:
		391	return SectionProvenance(source: "RDAP domain lookup", collectedAt: collectedAt, provider: "rdap.org", resolver: nil, resultSource: source)
		392	case .subdomains:
		393	return SectionProvenance(source: "Certificate transparency search", collectedAt: collectedAt, provider: "crt.sh", resolver: nil, resultSource: source)
		394	case .portScan:
		395	return SectionProvenance(source: "TCP port scan", collectedAt: collectedAt, provider: "Target host", resolver: nil, resultSource: source)
		396	case .suggestions:
		397	return SectionProvenance(source: "Availability suggestions", collectedAt: collectedAt, provider: "DomainDig heuristic", resolver: resolverDisplayName, resultSource: source)
		398	}
		399	}
		400
205	private func aggregateSource(_ sectionSources: [LookupResultSource]) -> LookupResultSource {	401	private func aggregateSource(_ sectionSources: [LookupResultSource]) -> LookupResultSource {
206	let normalizedSources = sectionSources.map { source -> LookupResultSource in	402	let normalizedSources = sectionSources.map { source -> LookupResultSource in
207	source == .mixed ? .cached : source	403	source == .mixed ? .cached : source
	@@ -259,44 +455,131 @@ struct DomainInspectionService {
259	case let .success(value):	455	case let .success(value):
260	return .success(value)	456	return .success(value)
261	case let .empty(message):	457	case let .empty(message):
262	return .empty(message)	458	return .empty(classifyFailure(from: message, defaultKind: .unavailable).message)
263	case let .error(message):	459	case let .error(message):
264	return .error(classifiedMessage(from: message))	460	return .error(classifyFailure(from: message).message)
265	}	461	}
266	}	462	}
267		463
268	private func classifiedMessage(from message: String) -> String {	464	private func classifyFailure(from message: String, defaultKind: InspectionErrorKind = .unknown) -> InspectionFailure {
269	let normalizedMessage = message.trimmingCharacters(in: .whitespacesAndNewlines)	465	let normalizedMessage = message.trimmingCharacters(in: .whitespacesAndNewlines)
270	let lowercasedMessage = normalizedMessage.lowercased()	466	let lowercasedMessage = normalizedMessage.lowercased()
271
272	if lowercasedMessage.hasPrefix("network error:")
273	\|\| lowercasedMessage.hasPrefix("timeout:")
274	\|\| lowercasedMessage.hasPrefix("rate limit:")
275	\|\| lowercasedMessage.hasPrefix("parsing error:") {
276	return normalizedMessage
277	}
278
279	if lowercasedMessage.contains("timed out") {	467	if lowercasedMessage.contains("timed out") {
280	return "Timeout: Request timed out"	468	return InspectionFailure(kind: .timeout, message: "Timed out", details: normalizedMessage)
281	}	469	}
282	if lowercasedMessage.contains("429")	470	if lowercasedMessage.contains("429")
283	\|\| lowercasedMessage.contains("too many requests")	471	\|\| lowercasedMessage.contains("too many requests")
284	\|\| lowercasedMessage.contains("rate limit") {	472	\|\| lowercasedMessage.contains("rate limit") {
285	return "Rate limit: Try again shortly"	473	return InspectionFailure(kind: .rateLimited, message: "Rate limited", details: normalizedMessage)
286	}	474	}
287	if lowercasedMessage.contains("cannot parse")	475	if lowercasedMessage.contains("cannot parse")
288	\|\| lowercasedMessage.contains("decoding")	476	\|\| lowercasedMessage.contains("decoding")
289	\|\| lowercasedMessage.contains("json") {	477	\|\| lowercasedMessage.contains("json") {
290	return "Parsing error: Invalid server response"	478	return InspectionFailure(kind: .parsing, message: "Could not parse response", details: normalizedMessage)
291	}	479	}
292	if lowercasedMessage.contains("offline")	480	if lowercasedMessage.contains("offline")
293	\|\| lowercasedMessage.contains("internet connection")	481	\|\| lowercasedMessage.contains("internet connection")
294	\|\| lowercasedMessage.contains("not connected")	482	\|\| lowercasedMessage.contains("not connected")
295	\|\| lowercasedMessage.contains("network connection") {	483	\|\| lowercasedMessage.contains("network connection") {
296	return "Network error: Offline"	484	return InspectionFailure(kind: .network, message: "Network unavailable", details: normalizedMessage)
297	}	485	}
		486	if lowercasedMessage.contains("unsupported") {
		487	return InspectionFailure(kind: .unsupported, message: "Unsupported for this target", details: normalizedMessage)
		488	}
		489	if lowercasedMessage == "unavailable" \|\| lowercasedMessage.contains("no a record available") {
		490	return InspectionFailure(kind: .unavailable, message: normalizedMessage, details: nil)
		491	}
		492	if defaultKind == .unavailable {
		493	return InspectionFailure(kind: .unavailable, message: normalizedMessage, details: nil)
		494	}
		495	return InspectionFailure(kind: .unknown, message: normalizedMessage.isEmpty ? defaultKind.title : normalizedMessage, details: normalizedMessage)
		496	}
298		497
299	return "Network error: \(normalizedMessage)"	498	private func captureFailure<Value>(
		499	for section: LookupSectionKind,
		500	result: ServiceResult<Value>,
		501	into errorDetails: inout [LookupSectionKind: InspectionFailure]
		502	) {
		503	switch result {
		504	case .success:
		505	return
		506	case let .empty(message):
		507	errorDetails[section] = classifyFailure(from: message, defaultKind: .unavailable)
		508	case let .error(message):
		509	errorDetails[section] = classifyFailure(from: message)
		510	}
		511	}
		512
		513	private func confidenceForAvailability(result: DomainAvailabilityResult, provenance: SectionProvenance?) -> ConfidenceLevel {
		514	guard result.status != .unknown else { return .low }
		515	if provenance?.provider?.localizedCaseInsensitiveContains("rdap.org") == true, result.status == .registered {
		516	return .high
		517	}
		518	if result.status == .registered {
		519	return .medium
		520	}
		521	return .low
		522	}
		523
		524	private func confidenceForOwnership(result: DomainOwnership?, error: String?) -> ConfidenceLevel {
		525	guard let result else { return error == nil ? .low : .low }
		526	let hasDirectRegistrationData = result.registrar != nil \|\| result.createdDate != nil \|\| result.expirationDate != nil
		527	return hasDirectRegistrationData ? .high : .medium
		528	}
		529
		530	private func confidenceForSubdomains(results: [DiscoveredSubdomain], error: String?) -> ConfidenceLevel {
		531	if !results.isEmpty {
		532	return .medium
		533	}
		534	return error == nil ? .low : .low
		535	}
		536
		537	private func confidenceForEmail(result: EmailSecurityResult?, error: String?) -> ConfidenceLevel {
		538	guard let result else { return error == nil ? .low : .low }
		539	let foundCount = [result.spf.found, result.dmarc.found, result.dkim.found, result.bimi.found, result.mtaSts?.txtFound == true]
		540	.filter { $0 }
		541	.count
		542	if foundCount >= 3 {
		543	return .high
		544	}
		545	if foundCount >= 1 {
		546	return .medium
		547	}
		548	return .low
		549	}
		550
		551	private func confidenceForGeolocation(result: IPGeolocation?, error: String?) -> ConfidenceLevel {
		552	guard let result else { return error == nil ? .low : .low }
		553	if result.city != nil && result.country_name != nil && result.latitude != nil && result.longitude != nil {
		554	return .high
		555	}
		556	if result.country_name != nil \|\| result.org != nil {
		557	return .medium
		558	}
		559	return .low
		560	}
		561
		562	private func validationIssues(
		563	for domain: String,
		564	snapshotTimestamp: Date,
		565	availability: DomainAvailabilityResult,
		566	dnsSections: [DNSSection],
		567	provenanceBySection: [LookupSectionKind: SectionProvenance]
		568	) -> [String] {
		569	var issues: [String] = []
		570	if domain.isEmpty {
		571	issues.append("Missing normalized domain")
		572	}
		573	if availability.domain.isEmpty {
		574	issues.append("Missing normalized availability domain")
		575	}
		576	if dnsSections.isEmpty && provenanceBySection[.dns] == nil {
		577	issues.append("Missing DNS provenance")
		578	}
		579	if snapshotTimestamp > Date().addingTimeInterval(5) {
		580	issues.append("Snapshot timestamp is in the future")
		581	}
		582	return issues
300	}	583	}
301		584
302	private func mapServiceResult<Value>(_ result: ServiceResult<Value>, emptyValue: Value) -> (value: Value, message: String?) {	585	private func mapServiceResult<Value>(_ result: ServiceResult<Value>, emptyValue: Value) -> (value: Value, message: String?) {

DomainReportBuilder.swift +28

	@@ -3,8 +3,22 @@ import Foundation
3	struct DomainReport: Codable {	3	struct DomainReport: Codable {
4	let domain: String	4	let domain: String
5	let timestamp: Date	5	let timestamp: Date
		6	let appVersion: String
		7	let resolverDisplayName: String
		8	let resolverURLString: String
		9	let dataSources: [String]
6	let resultSource: LookupResultSource	10	let resultSource: LookupResultSource
		11	let sectionProvenance: [LookupSectionKind: SectionProvenance]
		12	let errorDetails: [LookupSectionKind: InspectionFailure]
		13	let isPartialSnapshot: Bool
		14	let validationIssues: [String]
		15	let auditNote: String?
7	let availability: DomainAvailabilityStatus	16	let availability: DomainAvailabilityStatus
		17	let availabilityConfidence: ConfidenceLevel?
		18	let ownershipConfidence: ConfidenceLevel?
		19	let subdomainConfidence: ConfidenceLevel?
		20	let emailConfidence: ConfidenceLevel?
		21	let geolocationConfidence: ConfidenceLevel?
8	let ownership: DomainOwnership?	22	let ownership: DomainOwnership?
9	let dns: DNSResultSummary	23	let dns: DNSResultSummary
10	let web: WebResultSummary	24	let web: WebResultSummary
	@@ -71,8 +85,22 @@ struct DomainReportBuilder {
71	return DomainReport(	85	return DomainReport(
72	domain: snapshot.domain,	86	domain: snapshot.domain,
73	timestamp: snapshot.timestamp,	87	timestamp: snapshot.timestamp,
		88	appVersion: snapshot.appVersion,
		89	resolverDisplayName: snapshot.resolverDisplayName,
		90	resolverURLString: snapshot.resolverURLString,
		91	dataSources: snapshot.dataSources,
74	resultSource: snapshot.resultSource,	92	resultSource: snapshot.resultSource,
		93	sectionProvenance: snapshot.provenanceBySection,
		94	errorDetails: snapshot.errorDetails,
		95	isPartialSnapshot: snapshot.isPartialSnapshot,
		96	validationIssues: snapshot.validationIssues,
		97	auditNote: snapshot.note,
75	availability: snapshot.availabilityResult?.status ?? .unknown,	98	availability: snapshot.availabilityResult?.status ?? .unknown,
		99	availabilityConfidence: snapshot.availabilityConfidence,
		100	ownershipConfidence: snapshot.ownershipConfidence,
		101	subdomainConfidence: snapshot.subdomainConfidence,
		102	emailConfidence: snapshot.emailSecurityConfidence,
		103	geolocationConfidence: snapshot.geolocationConfidence,
76	ownership: snapshot.ownership,	104	ownership: snapshot.ownership,
77	dns: DNSResultSummary(	105	dns: DNSResultSummary(
78	resolverDisplayName: snapshot.resolverDisplayName,	106	resolverDisplayName: snapshot.resolverDisplayName,

DomainReportExporter.swift +91 −7

             "DomainDig Report",
             "Domain: \(report.domain)",
             "Timestamp: \(textDateFormatter.string(from: report.timestamp))",
+            "App Version: \(report.appVersion)",
+            "Resolver: \(report.resolverDisplayName)",
+            "Resolver URL: \(report.resolverURLString)",
             "Source: \(report.resultSource.label)",
-            "Availability: \(availabilityLabel(report.availability))"
+            "Availability: \(availabilityLabel(report.availability))",
+            "Availability Confidence: \(report.availabilityConfidence?.title ?? "N/A")"
         ]
+        if report.isPartialSnapshot {
+            lines.append("Snapshot Integrity: Partial snapshot")
+        }
+        if let auditNote = report.auditNote, !auditNote.isEmpty {
+            lines.append("Audit Note: \(auditNote)")
+        }
+        if !report.dataSources.isEmpty {
+            lines.append("Data Sources: \(report.dataSources.joined(separator: ", "))")
+        }
+        if !report.validationIssues.isEmpty {
+            lines.append("Validation: \(report.validationIssues.joined(separator: " | "))")
+        }
         appendSection("Summary", to: &lines) {
             [
                 "Primary IP: \(report.dns.primaryIP ?? "Unavailable")",
         appendSection("Ownership", to: &lines) {
             var ownershipLines = [
                 "Registrar: \(report.ownership?.registrar ?? "Unavailable")",
+                "Confidence: \(report.ownershipConfidence?.title ?? "N/A")",
                 "Created: \(ownershipDateLabel(report.ownership?.createdDate))",
                 "Expires: \(ownershipDateLabel(report.ownership?.expirationDate))",
                 "Nameservers: \(joined(report.ownership?.nameservers) ?? "Unavailable")",
                 "Status: \(joined(report.ownership?.status) ?? "Unavailable")",
                 "Abuse Contact: \(report.ownership?.abuseEmail ?? "Unavailable")"
             ]
+            if let provenance = report.sectionProvenance[.ownership] {
+                ownershipLines.append("Provenance: \(provenanceLabel(provenance))")
+            }
             if let error = report.dns.error, report.ownership == nil {
                 ownershipLines.append("Error: \(error)")
             } else if let error = report.changeSummary?.message, report.ownership == nil, report.ownership == nil {
         appendSection("DNS", to: &lines) {
             var dnsLines = [
-                "Resolver: \(report.dns.resolverDisplayName)",
-                "Resolver URL: \(report.dns.resolverURLString)",
                 "Lookup Duration: \(durationLabel(report.dns.lookupDurationMs))",
                 "Primary IP: \(report.dns.primaryIP ?? "Unavailable")",
                 "PTR: \(report.dns.ptrRecord ?? report.dns.ptrError ?? "Unavailable")",
                 "DNSSEC: \(dnssecLabel(report.dns.dnssecSigned))"
             ]
+            if let provenance = report.sectionProvenance[.dns] {
+                dnsLines.append("Provenance: \(provenanceLabel(provenance))")
+            }
             if let error = report.dns.error {
                 dnsLines.append("Error: \(error)")
             }
                 "HSTS Preloaded: \(booleanLabel(report.web.hstsPreloaded))",
                 "Header Count: \(report.web.headerCount)"
             ]
+            if let provenance = report.sectionProvenance[.ssl] {
+                webLines.append("TLS Provenance: \(provenanceLabel(provenance))")
+            }
+            if let provenance = report.sectionProvenance[.httpHeaders] {
+                webLines.append("HTTP Provenance: \(provenanceLabel(provenance))")
+            }
+            if let provenance = report.sectionProvenance[.redirectChain] {
+                webLines.append("Redirect Provenance: \(provenanceLabel(provenance))")
+            }
             if let tlsError = report.web.tlsError {
                 webLines.append("TLS Error: \(tlsError)")
             }
         appendSection("Email", to: &lines) {
             var emailLines = [report.email.summary]
+            emailLines.append("Confidence: \(report.emailConfidence?.title ?? "N/A")")
+            if let provenance = report.sectionProvenance[.emailSecurity] {
+                emailLines.append("Provenance: \(provenanceLabel(provenance))")
+            }
             if let records = report.email.records {
                 emailLines.append("SPF: \(recordLabel(records.spf))")
                 emailLines.append("DMARC: \(recordLabel(records.dmarc))")
             var networkLines = [
                 "Reachability: \(report.network.reachabilitySummary)",
                 "Geolocation: \(report.network.geolocationSummary)",
+                "Geolocation Confidence: \(report.geolocationConfidence?.title ?? "N/A")",
                 "Open Ports: \(report.network.openPorts.map(String.init).joined(separator: ", ").nilIfEmpty ?? "None")"
             ]
+            if let provenance = report.sectionProvenance[.ipGeolocation] {
+                networkLines.append("Geolocation Provenance: \(provenanceLabel(provenance))")
+            }
             if let error = report.network.reachabilityError {
                 networkLines.append("Reachability Error: \(error)")
             }
         }
         appendSection("Subdomains", to: &lines) {
+            var values = ["Confidence: \(report.subdomainConfidence?.title ?? "N/A")"]
+            if let provenance = report.sectionProvenance[.subdomains] {
+                values.append("Provenance: \(provenanceLabel(provenance))")
+            }
             if report.subdomains.isEmpty {
-                return ["None"]
+                values.append("None")
+                return values
             }
-            return report.subdomains.map { "- \($0)" }
+            values.append(contentsOf: report.subdomains.map { "- \($0)" })
+            return values
         }
         appendSection("Changes", to: &lines) {
                 return ["No comparison available"]
             }
-            return [
+            var values = [
                 "Has Changes: \(changeSummary.hasChanges ? "Yes" : "No")",
                 "Severity: \(changeSummary.severity.title)",
-                "Summary: \(changeSummary.message)",
+                "Inferred Summary: \(changeSummary.message)",
                 "Changed Sections: \(changeSummary.changedSections.isEmpty ? "None" : changeSummary.changedSections.joined(separator: ", "))"
             ]
+            if !changeSummary.observedFacts.isEmpty {
+                values.append("Observed: \(changeSummary.observedFacts.joined(separator: " | "))")
+            }
+            if let contextNote = changeSummary.contextNote {
+                values.append("Context: \(contextNote)")
+            }
+            return values
         }
         return lines.joined(separator: "\n")
         let headers = [
             "domain",
             "timestamp",
+            "app_version",
             "result_source",
+            "resolver",
             "availability",
+            "availability_confidence",
             "registrar",
+            "ownership_confidence",
             "ownership_expires",
             "nameservers",
             "primary_ip",
             "http_security_grade",
             "final_url",
             "email_summary",
+            "email_confidence",
             "subdomain_count",
+            "subdomain_confidence",
             "subdomains",
             "open_ports",
             "reachability_summary",
             "geolocation_summary",
+            "geolocation_confidence",
+            "data_sources",
+            "audit_note",
+            "partial_snapshot",
             "change_summary"
         ]
             return [
                 report.domain,
                 csvDateFormatter.string(from: report.timestamp),
+                report.appVersion,
                 report.resultSource.rawValue,
+                report.resolverDisplayName,
                 availabilityLabel(report.availability),
+                report.availabilityConfidence?.rawValue ?? "",
                 report.ownership?.registrar ?? "",
+                report.ownershipConfidence?.rawValue ?? "",
                 expirationDate,
                 nameservers,
                 report.dns.primaryIP ?? "",
                 report.web.securityGrade ?? "",
                 report.web.finalURL ?? "",
                 report.email.summary,
+                report.emailConfidence?.rawValue ?? "",
                 subdomainCount,
+                report.subdomainConfidence?.rawValue ?? "",
                 subdomains,
                 openPorts,
                 report.network.reachabilitySummary,
                 report.network.geolocationSummary,
+                report.geolocationConfidence?.rawValue ?? "",
+                report.dataSources.joined(separator: " | "),
+                report.auditNote ?? "",
+                report.isPartialSnapshot ? "true" : "false",
                 report.changeSummary?.message ?? ""
             ]
         }
         return "Unavailable"
     }
+    private static func provenanceLabel(_ provenance: SectionProvenance) -> String {
+        [
+            provenance.source,
+            provenance.provider,
+            provenance.resolver.map { "resolver=\($0)" },
+            provenance.resultSource.label.lowercased(),
+            textDateFormatter.string(from: provenance.collectedAt)
+        ]
+        .compactMap { $0 }
+        .joined(separator: " | ")
+    }
     private static let textDateFormatter: DateFormatter = {
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyy-MM-dd HH:mm:ss"

LookupSnapshot.swift +25 −1

	@@ -5,8 +5,20 @@ struct LookupSnapshot {
5	let domain: String	5	let domain: String
6	let timestamp: Date	6	let timestamp: Date
7	let trackedDomainID: UUID?	7	let trackedDomainID: UUID?
		8	let note: String?
		9	let appVersion: String
8	let resolverDisplayName: String	10	let resolverDisplayName: String
9	let resolverURLString: String	11	let resolverURLString: String
		12	let dataSources: [String]
		13	let provenanceBySection: [LookupSectionKind: SectionProvenance]
		14	let availabilityConfidence: ConfidenceLevel?
		15	let ownershipConfidence: ConfidenceLevel?
		16	let subdomainConfidence: ConfidenceLevel?
		17	let emailSecurityConfidence: ConfidenceLevel?
		18	let geolocationConfidence: ConfidenceLevel?
		19	let errorDetails: [LookupSectionKind: InspectionFailure]
		20	let isPartialSnapshot: Bool
		21	let validationIssues: [String]
10	let totalLookupDurationMs: Int?	22	let totalLookupDurationMs: Int?
11	let dnsSections: [DNSSection]	23	let dnsSections: [DNSSection]
12	let dnsError: String?	24	let dnsError: String?
	@@ -55,8 +67,20 @@ extension HistoryEntry {
55	domain: domain,	67	domain: domain,
56	timestamp: timestamp,	68	timestamp: timestamp,
57	trackedDomainID: trackedDomainID,	69	trackedDomainID: trackedDomainID,
		70	note: note,
		71	appVersion: appVersion,
58	resolverDisplayName: resolverDisplayName,	72	resolverDisplayName: resolverDisplayName,
59	resolverURLString: resolverURLString,	73	resolverURLString: resolverURLString,
		74	dataSources: dataSources,
		75	provenanceBySection: provenanceBySection,
		76	availabilityConfidence: availabilityConfidence,
		77	ownershipConfidence: ownershipConfidence,
		78	subdomainConfidence: subdomainConfidence,
		79	emailSecurityConfidence: emailSecurityConfidence,
		80	geolocationConfidence: geolocationConfidence,
		81	errorDetails: errorDetails,
		82	isPartialSnapshot: isPartialSnapshot,
		83	validationIssues: validationIssues,
60	totalLookupDurationMs: totalLookupDurationMs,	84	totalLookupDurationMs: totalLookupDurationMs,
61	dnsSections: dnsSections,	85	dnsSections: dnsSections,
62	dnsError: nil,	86	dnsError: nil,
	@@ -89,7 +113,7 @@ extension HistoryEntry {
89	portScanResults: portScanResults,	113	portScanResults: portScanResults,
90	portScanError: portScanError,	114	portScanError: portScanError,
91	changeSummary: changeSummary,	115	changeSummary: changeSummary,
92	resultSource: .snapshot,	116	resultSource: resultSource,
93	cachedSections: [],	117	cachedSections: [],
94	statusMessage: nil	118	statusMessage: nil
95	)	119	)

Commit 7b41195620

Commit `7b41195620`