fix(launch): paint first Sessions snapshot within seconds of warm hydration

CHANGELOG.md

@@ -28,6 +28,11 @@ All notable changes to trifola are documented here. The format follows
 - **Warm-launch session hydration** — cached SQLite accumulator payloads decode concurrently in
   bounded batches, so a valid index publishes before the background scan without changing session
   contents or numbering.
+- **Sessions first-snapshot stall** — the Sessions view no longer sits in “Preparing session index”
+  for the length of the validation scan after the corpus hydrates. The first lineage snapshot paints
+  within a few seconds via stale-while-revalidate — the newest completed forest serves immediately,
+  a fresh resolve is never cancelled by a scan batch and swaps in silently, and revalidation runs at
+  background priority — leaving the resolved lineage and session counts unchanged.
 
 ## [0.4.0] - 2026-07-18
 

Sources/Trifola/AppServices.swift

@@ -259,6 +259,18 @@ final class AppServices: ObservableObject {
             .sink { [weak self] _ in self?.objectWillChange.send() }
             .store(in: &forwarders)
 
+        // The session list must rebuild when the STORE publishes, not when
+        // `refreshNow` returns: a warm launch hydrates the corpus in ~3s but
+        // the validation scan keeps refreshNow awaiting for its full duration,
+        // and completion-ordered rebuilds left the first Sessions snapshot
+        // starving behind the whole scan.
+        sessions.$sessions
+            .dropFirst()
+            .throttle(for: .milliseconds(500), scheduler: DispatchQueue.main,
+                      latest: true)
+            .sink { [weak self] _ in self?.refreshNavigationSnapshots() }
+            .store(in: &forwarders)
+
         // Each committed FTS batch is immediately queryable through WAL. Refresh
         // the detached search projection at a bounded cadence so a first-run query
         // gains partial results without waiting for the final batch.

Sources/Trifola/NavigationSnapshotStore.swift

@@ -152,6 +152,11 @@ final class NavigationSnapshotStore: ObservableObject {
         (source: LineageSource, resolution: SessionLineageResolution)?
     private var lineageInFlight:
         (source: LineageSource, task: Task<SessionLineageResolution?, Never>)?
+    /// Newest completed resolution regardless of source — the
+    /// stale-while-revalidate forest. On a warm launch the hydrated corpus is
+    /// ≈ final, so serving it while batches revalidate is honest; the fresh
+    /// forest swaps in silently when its resolve completes.
+    private var lastLineageResolution: SessionLineageResolution?
     private var corpusGeneration = 0
     private var fleetGeneration = 0
     private var deadlineGeneration = 0
@@ -237,10 +242,11 @@ final class NavigationSnapshotStore: ObservableObject {
         if lineageMemo?.source != lineageSource {
             lineageMemo = nil
         }
-        if let pending = lineageInFlight, pending.source != lineageSource {
-            pending.task.cancel()
-            lineageInFlight = nil
-        }
+        // An in-flight resolve for an older source is NOT cancelled: during a
+        // validation scan every batch bumps the revision, and cancel-restart
+        // starved the first snapshot for the whole scan. The old resolve
+        // completes as the stale-while-revalidate forest; a fresh resolve
+        // follows once it lands.
         inputs = Inputs(
             sessions: sessions,
             attentionSignals: attentionSignals,
@@ -385,6 +391,27 @@ final class NavigationSnapshotStore: ObservableObject {
         }
     }
 
+    /// A lineage resolve finished. Record it as the freshest forest, memoize
+    /// when it still matches the live inputs, and re-schedule so a snapshot
+    /// that painted a stale forest swaps to this one silently. When inputs
+    /// moved on mid-resolve, the re-schedule starts the follow-up resolve.
+    private func lineageResolveCompleted(
+        source: LineageSource,
+        task: Task<SessionLineageResolution?, Never>,
+        resolution: SessionLineageResolution?
+    ) {
+        if lineageInFlight?.task == task { lineageInFlight = nil }
+        guard let resolution else { return }
+        lastLineageResolution = resolution
+        if let inputs, LineageSource(
+            sessionsRevision: inputs.sessionsRevision,
+            evidenceRevision: inputs.lineageEvidenceRevision,
+            includeHeuristics: inputs.showHeuristicLinks) == source {
+            lineageMemo = (source: source, resolution: resolution)
+        }
+        scheduleSessions()
+    }
+
     private func scheduleSessions(debounce: Bool = false) {
         guard let inputs else { return }
         sessionGeneration += 1
@@ -397,19 +424,38 @@ final class NavigationSnapshotStore: ObservableObject {
         let cachedResolution = lineageMemo.flatMap {
             $0.source == lineageSource ? $0.resolution : nil
         }
+        let staleResolution = lastLineageResolution
         let resolutionTask: Task<SessionLineageResolution?, Never>? = {
             guard cachedResolution == nil else { return nil }
-            if let pending = lineageInFlight,
-               pending.source == lineageSource {
+            if let pending = lineageInFlight {
+                // One resolve at a time, never cancelled for a newer source —
+                // its completion re-schedules and the follow-up resolve picks
+                // up the newest inputs.
                 return pending.task
             }
             let task = Task.detached(priority: .userInitiated) {
-                try? SessionLineage.resolveWithIndexCancellable(
-                    sessions: inputs.sessions,
-                    evidence: inputs.lineageEvidence,
-                    includeHeuristicLinks: inputs.showHeuristicLinks)
+                // Hop to GCD: the cooperative pool can be saturated by a
+                // corpus scan, and the first snapshot must not starve behind
+                // it. GCD over-commits, so this resolve always gets a thread.
+                await withCheckedContinuation { continuation in
+                    DispatchQueue.global(qos: .userInitiated).async {
+                        continuation.resume(
+                            returning: try? SessionLineage.resolveWithIndexCancellable(
+                                sessions: inputs.sessions,
+                                evidence: inputs.lineageEvidence,
+                                includeHeuristicLinks: inputs.showHeuristicLinks))
+                    }
+                }
             }
             lineageInFlight = (source: lineageSource, task: task)
+            Task { [weak self] in
+                let resolution = await task.value
+                await MainActor.run {
+                    self?.lineageResolveCompleted(
+                        source: lineageSource, task: task,
+                        resolution: resolution)
+                }
+            }
             return task
         }()
         sessionTask?.cancel()
@@ -424,20 +470,15 @@ final class NavigationSnapshotStore: ObservableObject {
             let resolution: SessionLineageResolution
             if let cachedResolution {
                 resolution = cachedResolution
+            } else if let staleResolution {
+                // Serve the newest completed forest NOW; the in-flight resolve
+                // re-schedules a silent swap when it lands.
+                resolution = staleResolution
             } else if let resolutionTask {
+                // First-ever paint with nothing to show — the only case that
+                // waits on a resolve.
                 guard let completed = await resolutionTask.value else { return }
                 resolution = completed
-                guard let self else { return }
-                if self.inputs.map({ LineageSource(
-                    sessionsRevision: $0.sessionsRevision,
-                    evidenceRevision: $0.lineageEvidenceRevision,
-                    includeHeuristics: $0.showHeuristicLinks)
-                }) == lineageSource {
-                    self.lineageMemo = (
-                        source: lineageSource,
-                        resolution: resolution)
-                    self.lineageInFlight = nil
-                }
             } else {
                 return
             }
@@ -522,6 +563,12 @@ final class NavigationSnapshotStore: ObservableObject {
                   self.sessionGeneration == generation else { return }
             var state = self.sessionSearch
             guard state.publish(result, for: request) else { return }
+            if self.sessionSearch.displayed == nil,
+               ProcessInfo.processInfo.environment["TRIFOLA_LAUNCH_METRICS"] == "1" {
+                FileHandle.standardError.write(Data(
+                    "[launch-metric] first sessions snapshot: \(result.rows.count) rows\n"
+                        .utf8))
+            }
             self.sessionSearch = state
         }
     }

Sources/TrifolaKit/Stores.swift

@@ -1552,7 +1552,12 @@ public final class SessionStore: ObservableObject {
                 claudeProjectsRoot: lineageProjectsURL,
                 codexImportManifestURL: lineageManifestURL)
         }.value
-        let result = await Task.detached(priority: .userInitiated) { [weak self] in
+        // A warm launch already showed the hydrated corpus; revalidation is
+        // background work and must not starve the first snapshot's lineage
+        // resolve out of the cooperative pool. A cold start IS the content.
+        let scanPriority: TaskPriority = index.entries.isEmpty
+            ? .userInitiated : .utility
+        let result = await Task.detached(priority: scanPriority) { [weak self] in
             let publish: @Sendable (SessionIndex, SessionScanProgress) -> Void = {
                 [weak self] partial, progress in
                 latestProgress.withLock { $0 = progress }

Tests/TrifolaKitTests/NavigationSnapshotShapeTests.swift

@@ -35,8 +35,23 @@ struct NavigationSnapshotShapeTests {
 
         #expect(source.contains("sessionsRevision: inputs.sessionsRevision"))
         #expect(source.contains("evidenceRevision: inputs.lineageEvidenceRevision"))
-        #expect(source.contains("pending.source == lineageSource"))
         #expect(source.contains("SessionLineage.resolveWithIndex"))
         #expect(!source.contains("summaries.map { (SessionLineage.key($0), $0) }"))
     }
+
+    @Test("A snapshot never starves behind lineage: stale forest serves, resolves are never cancelled for a newer source")
+    func lineageIsStaleWhileRevalidate() throws {
+        let source = try snapshotSource
+
+        // Any in-flight resolve is reused — never keyed to the current source
+        // and never cancelled when a scan batch bumps the revision (the
+        // cancel-restart pattern starved the first snapshot for a whole scan).
+        #expect(source.contains("if let pending = lineageInFlight {"))
+        #expect(!source.contains("pending.task.cancel()"))
+        // The newest completed forest paints immediately…
+        #expect(source.contains("lastLineageResolution"))
+        #expect(source.contains("} else if let staleResolution {"))
+        // …and a completed resolve re-schedules the silent swap.
+        #expect(source.contains("func lineageResolveCompleted"))
+    }
 }

docs/ARCHITECTURE.md

@@ -180,8 +180,8 @@ An observability app that pegs a CPU core is disqualifying here. The pipeline is
 (FSEvents) with no polling render loop; scans are off-main and incremental. Warm launch reads
 SQLite on one thread while accumulator payloads decode concurrently in bounded batches, then
 publishes the unchanged cached index before reconciliation. Set `TRIFOLA_LAUNCH_METRICS=1` to emit
-cache-hydration and scan-reconciliation entry counts and timings to standard error. Destination
-navigation is budgeted and benchmarked.
+cache-hydration and scan-reconciliation entry counts and timings, plus the first Sessions snapshot's
+row count, to standard error. Destination navigation is budgeted and benchmarked.
 
 ## Testing