Separate provider polling from passive CLI file refresh

EFFORT-LOG.md

@@ -1,5 +1,16 @@
 # CodeCaps — Effort Log
 
+## 2026-10-03 — Independent Provider and File Refresh [CODEX, PR #142]
+
+repo: CodeCaps; pre-work claim: posted to #agent-sync after reading AGENT-SYNC.md; Lane: `codex/independent-source-refresh`; Board `4bcf84f1`; GitHub #137; PR #142 open on this branch (depends on #139; refs #136).
+
+- Added `CodexSessionQuotaReader` for bounded passive Codex session JSONL reads with exact account identity, incremental append tracking, symlink-safe paths, and original event timestamps.  Unchanged files do not invoke provider, Fleet, upload, or download work.
+- Split Settings → Sources & Fleet into independent **Provider Checks** and **Codex Session File Checks** toggles with separate 1-, 3-, 5-, and 15-minute intervals (five-minute provider default, one-minute file default).  Manual refresh runs both enabled paths; disabling one source preserves the other when possible.
+- Integrated scheduling, merge rules, and cancellation in `MonitorModel` / `SourceRefreshSettings`; documented behavior in `docs/REFRESH.md`.
+- Verification: `CodexSessionQuotaReaderTests`, `SourceRefreshTests`, and related refresh tests on the branch; hosted Swift CI green.  Native Mac UI claims rely on code review and CI fixture rendering in `DocsScreenshotTests`, not supplied or manually captured screenshots.
+
+---
+
 ## 2026-10-03 — Audit 9 Residual Reconciliation [CODEX, in progress]
 
 Lane: `codex/audit-residuals`.  Board `1ac04ba99f13478da0564f802d3af3e8`; GitHub #19.

Sources/CodeCaps/ConsoleViews.swift

@@ -231,7 +231,6 @@ final class ConsoleState: ObservableObject {
         unavailableAlert = nil
         pendingAlert = nil
     }
-
     func clearHistoryFocus() {
         selectedWindowId = nil
         selectedTimestamp = nil

Sources/CodeCaps/SettingsViews.swift

@@ -295,6 +295,24 @@ struct SettingsSourcesFleetPage: View {
 
             Toggle("Read Quotas From This Mac",
                    isOn: Binding(get: { model.localEnabled }, set: { model.setLocalEnabled($0) }))
+            Toggle("Provider Checks", isOn: Binding(
+                get: { model.providerChecksEnabled }, set: { model.setProviderChecksEnabled($0) }))
+                .disabled(!model.localEnabled)
+            Picker("Provider Check Interval", selection: $model.providerCheckCadence) {
+                ForEach(SourceRefreshCadence.allCases) { cadence in
+                    Text(cadence.title).tag(cadence)
+                }
+            }
+            .disabled(!model.localEnabled || !model.providerChecksEnabled)
+            Toggle("Codex Session File Checks", isOn: Binding(
+                get: { model.sessionFileChecksEnabled }, set: { model.setSessionFileChecksEnabled($0) }))
+                .disabled(!model.localEnabled)
+            Picker("Session File Check Interval", selection: $model.sessionFileCadence) {
+                ForEach(SourceRefreshCadence.allCases) { cadence in
+                    Text(cadence.title).tag(cadence)
+                }
+            }
+            .disabled(!model.localEnabled || !model.sessionFileChecksEnabled)
             ForEach(ReaderStatus.all, id: \.providerKey) { reader in
                 readerRow(reader)
             }
@@ -304,6 +322,10 @@ struct SettingsSourcesFleetPage: View {
             VStack(alignment: .leading, spacing: 4) {
                 Text("CodeCaps reads each CLI's own saved credentials in place." + sentenceGap
                      + "It never asks you for a provider API key.")
+                Text("Provider Checks: 7 HTTP paths and 3 local helpers across 8 AI plan families." + sentenceGap
+                     + "These are source capabilities, not a request count per check.")
+                Text("Codex Session File Checks: 1 local quota source." + sentenceGap
+                     + "File checks do not upload or download on their own.")
                 Text("A snapshot is written to ~/Library/Application Support/Usage Monitor/quota-windows.json for BotFleet.")
                 if let widgetSharingError = model.widgetSharingError {
                     Text(widgetSharingError).foregroundStyle(Theme.warning)
@@ -1136,6 +1158,15 @@ struct SettingsNotificationsPage: View {
 
     var body: some View {
         SettingsPage {
+            if let row = model.displaySections.first(where: {
+                $0.providerKey == model.runawayAlertHistory.first?.providerKey
+            }) ?? model.displaySections.first {
+                Section {
+                    UsageHistoryView(model: model, state: state, row: row)
+                } header: {
+                    Eyebrow("RECENT USAGE HISTORY")
+                }
+            }
             Section {
                 Toggle("Reset Alarms For All Providers", isOn: $model.alarmsAll)
                     .help("The same switch as the All bell at the top of the Docked Bar.")

Sources/CodeCaps/SourceRefreshSettings.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+enum SourceRefreshCadence: Int, CaseIterable, Identifiable {
+    case one = 1
+    case three = 3
+    case five = 5
+    case fifteen = 15
+
+    var id: Int { rawValue }
+    var seconds: TimeInterval { TimeInterval(rawValue * 60) }
+    var title: String { "Every \(rawValue) minute\(rawValue == 1 ? "" : "s")" }
+}
+
+enum SourceRefreshPreference {
+    static let providerEnabled = "providerChecksEnabled"
+    static let sessionEnabled = "sessionFileChecksEnabled"
+    static let providerMinutes = "providerCheckMinutes"
+    static let sessionMinutes = "sessionFileCheckMinutes"
+
+    static func enabled(_ key: String, defaults: UserDefaults) -> Bool {
+        defaults.object(forKey: key) as? Bool ?? true
+    }
+
+    static func cadence(_ key: String, fallback: SourceRefreshCadence,
+                        defaults: UserDefaults) -> SourceRefreshCadence {
+        SourceRefreshCadence(rawValue: defaults.integer(forKey: key)) ?? fallback
+    }
+}

Sources/CodeCaps/UsageHistoryViews.swift

@@ -33,8 +33,6 @@ struct UsageHistoryView: View {
         self.model = model
         self.state = state
         self.row = row
-        // Offscreen AppKit snapshots can draw before SwiftUI calls onAppear.
-        _samples = State(initialValue: model.historySamples())
     }
 
     private var now: Date { model.now }
@@ -128,7 +126,7 @@ struct UsageHistoryView: View {
                 VStack(alignment: .leading, spacing: 2) {
                     Text("Usage History")
                         .font(.system(size: 16, weight: .semibold))
-                    Text("Quota remaining · local readings")
+                    Text("\(row.title) · Quota remaining · local readings")
                         .font(.system(size: 11))
                         .foregroundStyle(.secondary)
                 }

Sources/QuotaCore/AnomalyDetector.swift

@@ -243,10 +243,13 @@ public struct AnomalyDetector: Sendable {
             encoder.dateEncodingStrategy = .iso8601
             encoder.outputFormatting = [.withoutEscapingSlashes]
             let fm = FileManager.default
-            let existing = try load()
-            var seen = Set(existing.map {
-                SampleKey(pair: PairKey(provider: $0.providerKey, window: $0.windowId), time: $0.observedAt)
-            })
+            // Dedup against a tail read only: decoding the whole file here ran
+            // a multi-megabyte parse on the main thread on every recorded
+            // refresh.  Duplicates can only come from re-appending a recent
+            // batch (identical observedAt timestamps), so the tail is
+            // sufficient; load() dedups by key on read anyway, making a missed
+            // older duplicate harmless.
+            var seen = tailSampleKeys(maxBytes: 64 * 1024)
             let fresh = samples.filter { sample in
                 guard sample.observedAt.timeIntervalSinceReferenceDate.isFinite,
                       let percent = sample.remainingPercent,
@@ -285,9 +288,30 @@ public struct AnomalyDetector: Sendable {
             }
         }
 
+        /// SampleKeys decoded from the last `maxBytes` of the history file, for
+        /// append-time dedup without a full parse.  The first line of the
+        /// slice may be cut mid-line and is skipped.
+        private func tailSampleKeys(maxBytes: Int) -> Set<SampleKey> {
+            guard let full = try? Data(contentsOf: url, options: .mappedIfSafe), !full.isEmpty else { return [] }
+            let sliced = full.count > maxBytes
+            let tail: Data = sliced ? full.suffix(maxBytes) : full
+            let decoder = JSONDecoder()
+            decoder.dateDecodingStrategy = .iso8601
+            var seen = Set<SampleKey>()
+            var lines = tail.split(separator: 0x0A, omittingEmptySubsequences: true)
+            if sliced { lines = Array(lines.dropFirst()) }
+            for line in lines {
+                if let sample = try? decoder.decode(Sample.self, from: Data(line)) {
+                    seen.insert(SampleKey(pair: PairKey(provider: sample.providerKey,
+                                                       window: sample.windowId),
+                                          time: sample.observedAt))
+                }
+            }
+            return seen
+        }
+
         /// Load every sample currently on disk.
-        public func load() throws -> [Sample] {
-            guard FileManager.default.fileExists(atPath: url.path) else { return [] }
+        public func load() throws -> [Sample] {            guard FileManager.default.fileExists(atPath: url.path) else { return [] }
             let data = try Data(contentsOf: url)
             let decoder = JSONDecoder()
             decoder.dateDecodingStrategy = .iso8601