feat: per-project token usage, merge Insights into Activity, 24H chart (#113)

* feat: add per-project token usage section between Tokens and Activity

Groups JSONL entries by working directory (cwd) to show which projects
consume the most tokens and estimated cost. Uses full cwd path as
grouping key to avoid collisions between identically-named directories.

* fix: correct id field comment and spec docs to reflect full cwd path key

The id field uses the full cwd path (not lastPathComponent) after the
path collision fix. Updates the struct comment and DATA_LAYER.md to match.

* feat: polish token sections — better wording, compact cost, 6-project limit with expand/search/sort

- Rename "Tokens" → "Token Usage" for clarity
- Prefix all cost values with "~" to indicate API-equivalent estimate
- Add formatCompactCost that drops cents for >= $1 (e.g. "$18")
- Projects section: show top 6, "Show all (N)" expand toggle, search
  filter when expanded, sort toggle (by tokens / by cost)
- Widen Token Usage cost column to 54pt for "~" prefix
- Project cost uses tertiaryLabel for visual separation from token values

* feat: merge Insights into Activity section, expand hourly chart to 24H

- Change hourly chart from 12-hour to 24-hour trailing window
- Move All Time, Longest session, and Period rows into Activity section
- Delete InsightsSection.swift (functionality merged into ActivityChartView)
- Add sort/search/expand controls to ProjectUsageSection
- Remove orphaned insightsCollapsed UserDefaults key
- Update all spec files and README test coverage

* fix: remove stale insights comment and force unwrap in ProjectUsageSection

- Comment referenced deleted "insights" section, updated to "insight rows"
- Replace force unwrap in ProjectSortMode.next with guard-let fallback

---------

Co-authored-by: KyleNesium <22541778+KyleNesium@users.noreply.github.com>

Author: KyleNesium

AIBattery/Models/ModelPricing.swift

@@ -29,6 +29,23 @@ struct ModelPricing {
         return String(format: "$%.2f", cost)
     }
 
+    /// Compact cost format — drops cents for >= $1 (e.g. "$18"), keeps precision for small amounts.
+    static func formatCompactCost(_ cost: Double) -> String {
+        if cost == 0 {
+            return "$0"
+        }
+        if cost < 0.01 {
+            return "<$0.01"
+        }
+        if cost < 1 {
+            return String(format: "$%.2f", cost)
+        }
+        if cost < 100 {
+            return String(format: "$%.0f", cost)
+        }
+        return String(format: "$%.0f", cost)
+    }
+
     /// Lookup cache — avoids repeated displayName + linear scan per model ID.
     /// Lock-protected for thread safety (Swift Testing runs tests concurrently).
     /// Uses `Optional<ModelPricing>` values; key presence means "already looked up",

AIBattery/Models/ProjectTokenSummary.swift

@@ -0,0 +1,15 @@
+import Foundation
+
+struct ProjectTokenSummary: Identifiable {
+    let id: String              // full cwd path (unique key; "Other" for nil cwd)
+    let projectName: String
+    let inputTokens: Int
+    let outputTokens: Int
+    let cacheReadTokens: Int
+    let cacheWriteTokens: Int
+    let estimatedCost: Double   // pre-computed from per-entry model pricing
+
+    var totalTokens: Int {
+        inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens
+    }
+}

AIBattery/Models/UsageSnapshot.swift

@@ -26,6 +26,9 @@ struct UsageSnapshot {
     // Token breakdown per model
     let modelTokens: [ModelTokenSummary]
 
+    // Token breakdown per project (from JSONL cwd field)
+    let projectTokens: [ProjectTokenSummary]
+
     // Total tokens (pre-computed at construction to avoid per-render reduce)
     let totalTokens: Int
 

AIBattery/Services/UsageAggregator.swift

@@ -125,6 +125,7 @@ final class UsageAggregator {
         }
 
         let rawModelTokens = Self.buildModelTokens(from: modelTokensMap)
+        let projectTokens = Self.buildProjectTokens(from: allEntries)
 
         // Merge with persistent ledger — preserves high-water marks across stats-cache rebuilds.
         let modelTokens: [ModelTokenSummary]
@@ -224,6 +225,7 @@ final class UsageAggregator {
             todaySessions: todaySessions,
             todayToolCalls: todayToolCalls,
             modelTokens: modelTokens,
+            projectTokens: projectTokens,
             totalTokens: modelTokens.reduce(0) { $0 + $1.totalTokens },
             dailyActivity: activity,
             dailyAverage: activityStats.average,
@@ -245,6 +247,61 @@ final class UsageAggregator {
         return snapshot
     }
 
+    /// Group JSONL entries by project (full cwd path as key), compute per-entry cost.
+    /// Entries without cwd are grouped under "Other". JSONL-only — stats-cache lacks per-entry cwd.
+    private static func buildProjectTokens(from entries: [AssistantUsageEntry]) -> [ProjectTokenSummary] {
+        struct Accumulator {
+            var displayName: String
+            var input: Int = 0
+            var output: Int = 0
+            var cacheRead: Int = 0
+            var cacheWrite: Int = 0
+            var cost: Double = 0
+        }
+
+        var byProject: [String: Accumulator] = [:]
+        for entry in entries {
+            guard entry.model.hasPrefix("claude-") else { continue }
+
+            let key: String
+            let displayName: String
+            if let cwd = entry.cwd, !cwd.isEmpty {
+                key = cwd
+                displayName = URL(fileURLWithPath: cwd).lastPathComponent
+            } else {
+                key = "Other"
+                displayName = "Other"
+            }
+
+            var acc = byProject[key] ?? Accumulator(displayName: displayName)
+            acc.input += entry.inputTokens
+            acc.output += entry.outputTokens
+            acc.cacheRead += entry.cacheReadTokens
+            acc.cacheWrite += entry.cacheWriteTokens
+            if let pricing = ModelPricing.pricing(for: entry.model) {
+                acc.cost += pricing.cost(
+                    input: entry.inputTokens,
+                    output: entry.outputTokens,
+                    cacheRead: entry.cacheReadTokens,
+                    cacheWrite: entry.cacheWriteTokens
+                )
+            }
+            byProject[key] = acc
+        }
+
+        return byProject.map { key, acc in
+            ProjectTokenSummary(
+                id: key,
+                projectName: acc.displayName,
+                inputTokens: acc.input,
+                outputTokens: acc.output,
+                cacheReadTokens: acc.cacheRead,
+                cacheWriteTokens: acc.cacheWrite,
+                estimatedCost: acc.cost
+            )
+        }.sorted { $0.totalTokens > $1.totalTokens }
+    }
+
     /// Filter to Claude models, map to summaries, sort by total tokens descending.
     private static func buildModelTokens(
         from map: [String: (input: Int, output: Int, cacheRead: Int, cacheWrite: Int)]

AIBattery/Utilities/UserDefaultsKeys.swift

@@ -23,8 +23,8 @@ enum UserDefaultsKeys {
     static let throttleTimestamps = "aibattery_throttleTimestamps"
     static let contextCollapsed = "aibattery_contextCollapsed"
     static let tokensCollapsed = "aibattery_tokensCollapsed"
+    static let projectsCollapsed = "aibattery_projectsCollapsed"
     static let activityCollapsed = "aibattery_activityCollapsed"
-    static let insightsCollapsed = "aibattery_insightsCollapsed"
     /// Prefix for per-account token expiry timestamps (append account ID).
     static let tokenExpiresAtPrefix = "aibattery_expiresAt_"
 }

AIBattery/Views/ActivityChartData.swift

@@ -43,13 +43,13 @@ enum ActivityChartData {
         }
     }
 
-    // MARK: - Hourly (12H)
+    // MARK: - Hourly (24H)
 
-    /// Generates 12 hourly data points for the trailing 12-hour window.
+    /// Generates 24 hourly data points for the trailing 24-hour window.
     static func hourlyData(from hourCounts: [String: Int], now: Date = .now) -> [HourlyPoint] {
         let currentHour = Calendar.current.component(.hour, from: now)
-        return (0..<12).map { offset in
-            let hour = (currentHour - 11 + offset + 24) % 24
+        return (0..<24).map { offset in
+            let hour = (currentHour - 23 + offset + 24) % 24
             return HourlyPoint(offset: offset, hour: hour, count: hourCounts[String(hour)] ?? 0)
         }
     }

AIBattery/Views/ActivityChartView.swift

@@ -4,7 +4,7 @@ import Charts
 // MARK: - Chart Mode
 
 enum ActivityChartMode: String, CaseIterable {
-    case hourly = "12H"
+    case hourly = "24H"
     case daily = "7D"
     case monthly = "12M"
 }
@@ -105,7 +105,7 @@ struct ActivityChartView: View {
                     .frame(width: 120)
                     .scaleEffect(0.8, anchor: .trailing)
                     .accessibilityLabel("Activity time range")
-                    .accessibilityHint("Switch between 12 hour, 7 day, and 12 month views")
+                    .accessibilityHint("Switch between 24 hour, 7 day, and 12 month views")
                     .help("Switch activity chart time range")
                 }
             }
@@ -134,10 +134,11 @@ struct ActivityChartView: View {
                 }
             }
 
-            // Trend summary
+            // Trend summary + insight rows
             if !collapsed, let snapshot {
                 trendSummary(snapshot)
                     .accessibilityElement(children: .combine)
+                insightRows(snapshot)
             }
         }
         .padding(.horizontal, 16)
@@ -254,17 +255,17 @@ struct ActivityChartView: View {
         .accessibilityLabel(a11yLabel)
     }
 
-    // MARK: - Hourly Chart (12H)
+    // MARK: - Hourly Chart (24H)
 
     private var hourlyChart: some View {
         let data = cachedHourly
         let total = data.reduce(0) { $0 + $1.count }
         let peak = data.max(by: { $0.count < $1.count })
         let a11yLabel: String = {
             if let peak, peak.count > 0 {
-                return "12-hour activity chart. \(total) messages in trailing window. Peak hour: \(Self.formatHourLabel(peak.hour)) with \(peak.count) messages"
+                return "24-hour activity chart. \(total) messages in trailing window. Peak hour: \(Self.formatHourLabel(peak.hour)) with \(peak.count) messages"
             }
-            return "12-hour activity chart. \(total) messages in trailing window"
+            return "24-hour activity chart. \(total) messages in trailing window"
         }()
 
         return Chart {
@@ -302,7 +303,7 @@ struct ActivityChartView: View {
             }
         }
         .chartXAxis {
-            AxisMarks(values: [0, 3, 6, 9, 11]) { value in
+            AxisMarks(values: [0, 4, 8, 12, 16, 20, 23]) { value in
                 AxisValueLabel {
                     if let offset = value.as(Int.self), offset >= 0, offset < data.count {
                         Text(Self.formatHourLabel(data[offset].hour))
@@ -311,13 +312,13 @@ struct ActivityChartView: View {
                 }
             }
         }
-        .chartXScale(domain: 0...11)
+        .chartXScale(domain: 0...23)
         .chartYAxis { sharedYAxis }
         .chartPlotStyle { plot in plot.background(.clear) }
         .chartOverlay { proxy in
             chartHoverOverlay(proxy: proxy) { x in
                 guard let value: Double = proxy.value(atX: x) else { return }
-                selectedHourlyOffset = max(0, min(11, Int(value.rounded())))
+                selectedHourlyOffset = max(0, min(23, Int(value.rounded())))
             } onEnd: {
                 selectedHourlyOffset = nil
             }
@@ -460,6 +461,65 @@ struct ActivityChartView: View {
         }
     }
 
+    // MARK: - Insight rows (merged from former Insights section)
+
+    private static let insightLabelWidth: CGFloat = 55
+
+    @ViewBuilder
+    private func insightRows(_ snapshot: UsageSnapshot) -> some View {
+        // All Time
+        insightRow(
+            label: "All Time",
+            value: "\(snapshot.totalMessages) msgs \u{00B7} \(snapshot.totalSessions) sessions",
+            tooltip: "Cumulative activity across all sessions"
+        )
+        .accessibilityLabel("All time: \(snapshot.totalMessages) messages, \(snapshot.totalSessions) sessions")
+
+        // Longest session
+        if let duration = snapshot.longestSessionDuration, snapshot.longestSessionMessages > 0 {
+            insightRow(
+                label: "Longest",
+                value: "\(duration) \u{00B7} \(snapshot.longestSessionMessages) msgs",
+                tooltip: "Longest single session by duration"
+            )
+        }
+
+        // Date range
+        if let start = snapshot.firstSessionDate,
+           let lastDay = snapshot.dailyActivity.last?.date,
+           let end = DateFormatters.dateKey.date(from: lastDay) {
+            insightRow(
+                label: "Period",
+                value: DateFormatters.formatDateRange(from: start, to: end),
+                tooltip: "Date range of tracked data",
+                valueColor: ThemeColors.secondaryLabel
+            )
+        }
+    }
+
+    private func insightRow(
+        label: String,
+        value: String,
+        tooltip: String,
+        valueColor: Color = .primary
+    ) -> some View {
+        HStack {
+            Text(label)
+                .font(.caption)
+                .foregroundStyle(ThemeColors.secondaryLabel)
+                .frame(width: Self.insightLabelWidth, alignment: .leading)
+                .help(tooltip)
+            Spacer()
+            Text(value)
+                .font(.system(.caption, design: .monospaced))
+                .foregroundStyle(valueColor)
+                .contentTransition(.numericText())
+                .animation(.easeInOut(duration: 0.4), value: value)
+                .copyable(value)
+        }
+        .accessibilityElement(children: .combine)
+    }
+
     // MARK: - Tooltip annotation
 
     /// Shared tooltip label styling used by all chart hover annotations.