Show weekday + date on weekly reset labels

Weekly reset now reads "Resets Friday, Jun 6 · 3:00 PM" in the app and
full widget; small widget uses a compact "Fri, Jun 6" via a new
formatResetShort(). (Amir's local UI polish, folded in on top of v1.14.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitea/workflows/build.yml

@@ -0,0 +1,103 @@
+name: Build APK
+
+# Push to master / open a PR  → builds a DEBUG apk (smoke test, no secrets needed).
+# Push a tag like v1.14       → builds a SIGNED RELEASE apk and attaches it to the
+#                               Gitea release for that tag.
+on:
+  push:
+    branches: [master]
+    tags: ['v*']
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Install Android SDK
+        run: |
+          set -e
+          SDK="$GITHUB_WORKSPACE/android-sdk"
+          mkdir -p "$SDK/cmdline-tools"
+          curl -sSL -o /tmp/cmdtools.zip \
+            https://dl.google.com/android/repository/commandlinetools-linux-9862592_latest.zip
+          unzip -q /tmp/cmdtools.zip -d "$SDK/cmdline-tools"
+          mv "$SDK/cmdline-tools/cmdline-tools" "$SDK/cmdline-tools/latest"
+          # Feed "y" via process substitution, not a pipe: `yes |` triggers SIGPIPE (exit 141)
+          # once sdkmanager stops reading, and the step shell runs with `-eo pipefail`.
+          "$SDK/cmdline-tools/latest/bin/sdkmanager" --sdk_root="$SDK" --licenses >/dev/null < <(yes)
+          "$SDK/cmdline-tools/latest/bin/sdkmanager" --sdk_root="$SDK" \
+            "platform-tools" "platforms;android-34" "build-tools;34.0.0" >/dev/null
+
+      - name: Point Gradle at the SDK
+        run: echo "sdk.dir=$GITHUB_WORKSPACE/android-sdk" > local.properties
+
+      # ── Debug build: every push/PR that is NOT a tag ───────────────────────
+      - name: Build debug APK
+        if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+        run: ./gradlew :app:assembleDebug --no-daemon
+
+      # ── Release build: tags only (needs the KEYSTORE_BASE64 secret) ────────
+      - name: Decode signing keystore
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          if [ -z "${{ secrets.KEYSTORE_BASE64 }}" ]; then
+            echo "::error::KEYSTORE_BASE64 secret is not set — cannot build a signed release."
+            exit 1
+          fi
+          echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 -d > app/claude-widget-release.keystore
+
+      - name: Build release APK
+        if: startsWith(github.ref, 'refs/tags/')
+        run: ./gradlew :app:assembleRelease --no-daemon
+
+      # ── Stage whichever APK was produced ───────────────────────────────────
+      - name: Stage APK
+        run: |
+          mkdir -p out
+          if [ -f app/build/outputs/apk/release/app-release.apk ]; then
+            cp app/build/outputs/apk/release/app-release.apk out/claude-usage-widget.apk
+          else
+            cp app/build/outputs/apk/debug/app-debug.apk out/claude-usage-widget-debug.apk
+          fi
+          ls -la out/
+
+      - name: Upload APK artifact
+        uses: actions/upload-artifact@v3
+        continue-on-error: true
+        with:
+          name: apk
+          path: out/*.apk
+
+      # ── Attach the signed APK to the Gitea release on tag ──────────────────
+      - name: Publish APK to Gitea release
+        if: startsWith(github.ref, 'refs/tags/')
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          TAG="${GITHUB_REF#refs/tags/}"
+          API="${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}"
+          # Create the release if it doesn't exist yet (ignore "already exists").
+          curl -s -X POST "$API/releases" \
+            -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
+            -d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\",\"body\":\"Automated build of $TAG\"}" >/dev/null || true
+          RID=$(curl -s "$API/releases/tags/$TAG" -H "Authorization: token $TOKEN" \
+            | python3 -c "import sys,json;print(json.load(sys.stdin)['id'])")
+          # Replace any existing asset of the same name, then upload.
+          curl -s "$API/releases/$RID/assets" -H "Authorization: token $TOKEN" \
+            | python3 -c "import sys,json;[print(a['id']) for a in json.load(sys.stdin) if a['name']=='claude-usage-widget.apk']" \
+            | while read AID; do curl -s -X DELETE "$API/releases/$RID/assets/$AID" -H "Authorization: token $TOKEN"; done
+          curl -s -X POST "$API/releases/$RID/assets?name=claude-usage-widget.apk" \
+            -H "Authorization: token $TOKEN" \
+            -F "attachment=@out/claude-usage-widget.apk" >/dev/null
+          echo "Attached claude-usage-widget.apk to release $TAG"

README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="icon.png" width="108" alt="Claude Usage Widget">
+</p>
+
 # Claude Usage Widget
 
 Android home screen widget that shows your Claude Pro usage at a glance.
@@ -6,6 +10,15 @@ Android home screen widget that shows your Claude Pro usage at a glance.
 
 - **SESSION** bar — current 5-hour window utilization with reset time
 - **WEEKLY** bar — 7-day rolling usage with reset time
+- **Pace marker** — a colored tick on each bar shows where you *should be* right now to finish at
+  exactly 100% by reset. Tick color grades your projection: green (way under budget) → teal →
+  yellow → orange → red → purple (burning way too fast), with an "X% over/under pace" label.
+- **Peak-hours indicator** — a Claude burst icon that lights up 🔥 during Anthropic's peak window
+  (5–11 AM Pacific, Mon–Fri), when tokens burn faster, with a countdown to the window close.
+- **Usage history chart** — the app plots your session and weekly utilization over the past 7 days,
+  so you can see your consumption trend, not just the current snapshot.
+- **Usage alerts** — opt-in notifications when session or weekly usage crosses a threshold you set
+  (sliders, 50–100%). Each alert fires at most once per limit window, so you're never spammed.
 - Tap the widget to open the app; tap ⟳ to force-refresh
 - Responsive: works as 4×1 (compact) or 4×2 (full)
 - Auto-refreshes every 5 minutes in the background

app/build.gradle.kts

@@ -11,8 +11,8 @@ android {
         applicationId = "me.khodak.claudeusage"
         minSdk = 26
         targetSdk = 34
-        versionCode = 6
-        versionName = "1.5"
+        versionCode = 15
+        versionName = "1.14"
     }
 
     signingConfigs {
@@ -44,6 +44,7 @@ android {
 
     buildFeatures {
         viewBinding = true
+        buildConfig = true
     }
 }
 

app/src/main/AndroidManifest.xml

@@ -3,14 +3,16 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
-        android:allowBackup="true"
+        android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.ClaudeUsage"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:usesCleartextTraffic="false">
 
         <activity
@@ -43,6 +45,14 @@
             android:name=".AlarmReceiver"
             android:exported="false" />
 
+        <receiver
+            android:name=".BootReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
         <receiver
             android:name="androidx.work.impl.background.systemalarm.RescheduleReceiver"
             android:exported="false"

app/src/main/java/me/khodak/claudeusage/BarRenderer.kt

@@ -0,0 +1,59 @@
+package me.khodak.claudeusage
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+
+/**
+ * Draws a usage bar as a Bitmap: rounded track + rounded fill + an optional vertical pace tick.
+ * Used both in the home-screen widget (setImageViewBitmap) and the in-app card, so the two render
+ * identically. Bitmaps are rendered at a fixed width and stretched horizontally via ImageView
+ * scaleType=fitXY; height is fixed so there is no vertical distortion.
+ */
+object BarRenderer {
+
+    private const val TRACK_COLOR = 0xFF252525.toInt()
+
+    fun render(
+        usedPct: Int,
+        markerPct: Int?,
+        fillColor: Int,
+        markerColor: Int?,
+        wPx: Int = 500,
+        hPx: Int = 14,
+        cornerPx: Float = 7f
+    ): Bitmap {
+        val bmp = Bitmap.createBitmap(wPx, hPx, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bmp)
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+
+        // Track
+        paint.color = TRACK_COLOR
+        val full = RectF(0f, 0f, wPx.toFloat(), hPx.toFloat())
+        canvas.drawRoundRect(full, cornerPx, cornerPx, paint)
+
+        // Fill
+        val pct = usedPct.coerceIn(0, 100)
+        if (pct > 0) {
+            paint.color = fillColor
+            val fillW = (wPx * pct / 100f).coerceAtLeast(cornerPx * 2)
+            val fill = RectF(0f, 0f, fillW, hPx.toFloat())
+            canvas.drawRoundRect(fill, cornerPx, cornerPx, paint)
+        }
+
+        // Pace marker — a single clean tick showing "where you should be right now".
+        // One color (no tiers); rounded ends to match the bar.
+        if (markerPct != null && markerColor != null) {
+            val m = markerPct.coerceIn(0, 100)
+            val tickW = (wPx * 0.016f).coerceIn(6f, 10f)
+            var x = wPx * m / 100f
+            x = x.coerceIn(tickW / 2f, wPx - tickW / 2f)
+            paint.color = markerColor
+            val tick = RectF(x - tickW / 2f, 0f, x + tickW / 2f, hPx.toFloat())
+            canvas.drawRoundRect(tick, tickW / 2f, tickW / 2f, paint)
+        }
+
+        return bmp
+    }
+}

app/src/main/java/me/khodak/claudeusage/BootReceiver.kt

@@ -0,0 +1,15 @@
+package me.khodak.claudeusage
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import me.khodak.claudeusage.data.PreferencesManager
+
+class BootReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action != Intent.ACTION_BOOT_COMPLETED) return
+        if (!PreferencesManager(context).isLoggedIn()) return
+        UsageUpdateWorker.schedulePeriodicRefresh(context)
+        UsageUpdateWorker.triggerImmediateRefresh(context)
+    }
+}

app/src/main/java/me/khodak/claudeusage/ClaudeUsageWidget.kt

@@ -20,6 +20,7 @@ class ClaudeUsageWidget : AppWidgetProvider() {
         ids.forEach { updateWidget(context, manager, it) }
         if (PreferencesManager(context).isLoggedIn()) {
             UsageUpdateWorker.schedulePeriodicRefresh(context)
+            UsageUpdateWorker.triggerImmediateRefresh(context)
         }
     }
 
@@ -41,6 +42,15 @@ class ClaudeUsageWidget : AppWidgetProvider() {
         @Volatile internal var isRefreshing = false
         @Volatile internal var currentRotation = 0f
 
+        /** Redraw every placed widget from the current cached data (call after a refresh). */
+        fun notifyDataChanged(context: Context) {
+            val manager = AppWidgetManager.getInstance(context)
+            val ids = manager.getAppWidgetIds(
+                android.content.ComponentName(context, ClaudeUsageWidget::class.java)
+            )
+            ids.forEach { updateWidget(context, manager, it) }
+        }
+
         fun updateWidget(context: Context, manager: AppWidgetManager, widgetId: Int) {
             val prefs = PreferencesManager(context)
             val apiData = prefs.getUsageData()
@@ -86,14 +96,15 @@ class ClaudeUsageWidget : AppWidgetProvider() {
 
         private fun buildSmallViews(context: Context, prefs: PreferencesManager, apiData: UsageData?): RemoteViews {
             val v = RemoteViews(context.packageName, R.layout.widget_layout_small)
+            applyPeak(v, showText = false)
             if (!prefs.isLoggedIn()) {
                 v.setTextViewText(R.id.tv_session_value, "—")
                 v.setTextViewText(R.id.tv_session_label, "Not signed in")
                 v.setTextViewText(R.id.tv_weekly_value, "—")
                 v.setTextViewText(R.id.tv_weekly_label, "")
                 v.setTextViewText(R.id.tv_status, "")
-                v.setProgressBar(R.id.progress_bar, 100, 0, false)
-                v.setProgressBar(R.id.progress_bar_weekly, 100, 0, false)
+                v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(0, null, WEEKLY_FILL, null))
                 return v
             }
             val hasUtilization = apiData != null && apiData.fiveHourUtilization >= 0f
@@ -103,14 +114,14 @@ class ClaudeUsageWidget : AppWidgetProvider() {
                 hasUtilization -> {
                     val pct = apiData!!.fiveHourUtilization.toInt()
                     v.setTextViewText(R.id.tv_session_value, "$pct%")
-                    v.setProgressBar(R.id.progress_bar, 100, pct, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(pct, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, formatReset(apiData.utilizationResetAtEpoch))
                 }
                 hasApiMessages -> {
                     val rem = apiData!!.effectiveRemaining
                     val lim = apiData.messagesLimit
                     v.setTextViewText(R.id.tv_session_value, "$rem/$lim")
-                    v.setProgressBar(R.id.progress_bar, 100, apiData.progressPercent, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(apiData.progressPercent, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, formatReset(apiData.resetAtEpoch))
                 }
                 sessionStart > 0 -> {
@@ -118,25 +129,26 @@ class ClaudeUsageWidget : AppWidgetProvider() {
                     val h = TimeUnit.MILLISECONDS.toHours(elapsedMs)
                     val m = TimeUnit.MILLISECONDS.toMinutes(elapsedMs) % 60
                     v.setTextViewText(R.id.tv_session_value, if (h > 0) "${h}h${m}m" else "${m}m")
-                    v.setProgressBar(R.id.progress_bar, 100, 0, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, "active")
                 }
                 else -> {
                     v.setTextViewText(R.id.tv_session_value, "—")
-                    v.setProgressBar(R.id.progress_bar, 100, 0, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, "")
                 }
             }
             val hasWeekly = apiData != null && apiData.weeklyUtilization >= 0f
             if (hasWeekly) {
                 val wPct = apiData!!.weeklyUtilization.toInt()
+                val pace = PaceCalc.compute(apiData.weeklyUtilization, apiData.weeklyResetAtEpoch, PaceCalc.WEEKLY_WINDOW_MS)
                 v.setTextViewText(R.id.tv_weekly_value, "$wPct%")
-                v.setProgressBar(R.id.progress_bar_weekly, 100, wPct, false)
-                v.setTextViewText(R.id.tv_weekly_label, formatReset(apiData.weeklyResetAtEpoch))
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(wPct, pace?.markerPct, WEEKLY_FILL, if (pace != null) MARKER_COLOR else null))
+                v.setTextViewText(R.id.tv_weekly_label, formatResetShort(apiData.weeklyResetAtEpoch))
             } else {
                 val weeklyDays = Integer.bitCount(prefs.getWeeklyMask())
                 v.setTextViewText(R.id.tv_weekly_value, "${weeklyDays}d")
-                v.setProgressBar(R.id.progress_bar_weekly, 100, 0, false)
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(0, null, WEEKLY_FILL, null))
                 v.setTextViewText(R.id.tv_weekly_label, "")
             }
             val resetEpoch = apiData?.effectiveResetEpoch ?: -1L
@@ -156,6 +168,7 @@ class ClaudeUsageWidget : AppWidgetProvider() {
 
         private fun buildViews(context: Context, prefs: PreferencesManager, apiData: UsageData?): RemoteViews {
             val v = RemoteViews(context.packageName, R.layout.widget_layout)
+            applyPeak(v, showText = true)
 
             // ── Not logged in ────────────────────────────────────────────────
             if (!prefs.isLoggedIn()) {
@@ -164,7 +177,8 @@ class ClaudeUsageWidget : AppWidgetProvider() {
                 v.setTextViewText(R.id.tv_weekly_value, "—")
                 v.setTextViewText(R.id.tv_weekly_label, "Open app to sign in")
                 v.setTextViewText(R.id.tv_status, "")
-                v.setProgressBar(R.id.progress_bar, 100, 0, false)
+                v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(0, null, WEEKLY_FILL, null))
                 return v
             }
 
@@ -177,14 +191,14 @@ class ClaudeUsageWidget : AppWidgetProvider() {
                 hasUtilization -> {
                     val pct = apiData!!.fiveHourUtilization.toInt()
                     v.setTextViewText(R.id.tv_session_value, "$pct%")
-                    v.setProgressBar(R.id.progress_bar, 100, pct, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(pct, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, formatReset(apiData.utilizationResetAtEpoch))
                 }
                 hasApiMessages -> {
                     val rem = apiData!!.effectiveRemaining
                     val lim = apiData.messagesLimit
                     v.setTextViewText(R.id.tv_session_value, "$rem / $lim")
-                    v.setProgressBar(R.id.progress_bar, 100, apiData.progressPercent, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(apiData.progressPercent, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, formatReset(apiData.resetAtEpoch))
                 }
                 sessionStart > 0 -> {
@@ -193,12 +207,12 @@ class ClaudeUsageWidget : AppWidgetProvider() {
                     val m = TimeUnit.MILLISECONDS.toMinutes(elapsedMs) % 60
                     val display = if (h > 0) "${h}h ${m}m" else if (m > 0) "${m}m" else "Just started"
                     v.setTextViewText(R.id.tv_session_value, display)
-                    v.setProgressBar(R.id.progress_bar, 100, 0, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, "session active")
                 }
                 else -> {
                     v.setTextViewText(R.id.tv_session_value, "—")
-                    v.setProgressBar(R.id.progress_bar, 100, 0, false)
+                    v.setImageViewBitmap(R.id.bar_session, BarRenderer.render(0, null, SESSION_FILL, null))
                     v.setTextViewText(R.id.tv_session_label, "")
                 }
             }
@@ -207,13 +221,14 @@ class ClaudeUsageWidget : AppWidgetProvider() {
             val hasWeekly = apiData != null && apiData.weeklyUtilization >= 0f
             if (hasWeekly) {
                 val wPct = apiData!!.weeklyUtilization.toInt()
+                val pace = PaceCalc.compute(apiData.weeklyUtilization, apiData.weeklyResetAtEpoch, PaceCalc.WEEKLY_WINDOW_MS)
                 v.setTextViewText(R.id.tv_weekly_value, "$wPct%")
-                v.setProgressBar(R.id.progress_bar_weekly, 100, wPct, false)
-                v.setTextViewText(R.id.tv_weekly_label, formatReset(apiData.weeklyResetAtEpoch))
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(wPct, pace?.markerPct, WEEKLY_FILL, if (pace != null) MARKER_COLOR else null))
+                v.setTextViewText(R.id.tv_weekly_label, formatResetDay(apiData.weeklyResetAtEpoch))
             } else {
                 val weeklyDays = Integer.bitCount(prefs.getWeeklyMask())
                 v.setTextViewText(R.id.tv_weekly_value, "$weeklyDays d")
-                v.setProgressBar(R.id.progress_bar_weekly, 100, 0, false)
+                v.setImageViewBitmap(R.id.bar_weekly, BarRenderer.render(0, null, WEEKLY_FILL, null))
                 v.setTextViewText(R.id.tv_weekly_label, "active this week")
             }
 
@@ -237,6 +252,20 @@ class ClaudeUsageWidget : AppWidgetProvider() {
             return v
         }
 
+        private const val SESSION_FILL = 0xFFCC785C.toInt()
+        private const val WEEKLY_FILL = 0xFF7B8FCC.toInt()
+        private const val MARKER_COLOR = 0xFFFFFFFF.toInt()   // single-color pace marker (weekly only)
+
+        /** Tints the header burst icon and (optionally) the PEAK text by current peak state. */
+        private fun applyPeak(v: RemoteViews, showText: Boolean) {
+            val peak = PeakHours.isPeak()
+            v.setInt(R.id.img_peak, "setColorFilter",
+                if (peak) 0xFFCC785C.toInt() else 0xFF666666.toInt())
+            if (showText) {
+                v.setTextViewText(R.id.tv_peak, if (peak) "🔥 PEAK" else "")
+            }
+        }
+
         private fun formatReset(epochMs: Long): String {
             if (epochMs <= 0) return ""
             val now = System.currentTimeMillis()
@@ -250,6 +279,23 @@ class ClaudeUsageWidget : AppWidgetProvider() {
             }
         }
 
+        /** Weekly reset with weekday + date ("Resets Friday, Jun 6 · 3:00 PM"), never "tomorrow". */
+        private fun formatResetDay(epochMs: Long): String {
+            if (epochMs <= 0) return ""
+            if (epochMs <= System.currentTimeMillis()) return "Resets soon"
+            val day = SimpleDateFormat("EEEE", Locale.US).format(Date(epochMs))
+            val date = SimpleDateFormat("MMM d", Locale.US).format(Date(epochMs))
+            val timeStr = SimpleDateFormat("h:mm a", Locale.US).format(Date(epochMs))
+            return "Resets $day, $date · $timeStr"
+        }
+
+        /** Compact weekly reset for the space-tight small widget: "Fri, Jun 6". */
+        private fun formatResetShort(epochMs: Long): String {
+            if (epochMs <= 0) return ""
+            if (epochMs <= System.currentTimeMillis()) return "soon"
+            return SimpleDateFormat("EEE, MMM d", Locale.US).format(Date(epochMs))
+        }
+
         private fun formatTime(ms: Long) =
             SimpleDateFormat("h:mm a", Locale.US).format(Date(ms))
     }

app/src/main/java/me/khodak/claudeusage/HistoryChartView.kt

@@ -0,0 +1,131 @@
+package me.khodak.claudeusage
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.util.AttributeSet
+import android.view.View
+import me.khodak.claudeusage.data.UsageSnapshot
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Lightweight line chart for usage history, hand-drawn on Canvas to stay dependency-free
+ * and consistent with [BarRenderer]. Plots session (orange) and weekly (blue) utilization
+ * 0-100% over time. Gaps longer than [GAP_MS] are not connected, so an offline stretch
+ * shows as a break rather than a misleading straight line.
+ */
+class HistoryChartView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyle: Int = 0
+) : View(context, attrs, defStyle) {
+
+    private var points: List<UsageSnapshot> = emptyList()
+
+    private val gridPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = 0xFF2A2A2A.toInt(); strokeWidth = dp(1f); style = Paint.Style.STROKE
+    }
+    private val labelPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = 0xFF666666.toInt(); textSize = sp(10f)
+    }
+    private val sessionPaint = linePaint(0xFFCC785C.toInt())
+    private val weeklyPaint = linePaint(0xFF7B8FCC.toInt())
+    private val emptyPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = 0xFF666666.toInt(); textSize = sp(13f); textAlign = Paint.Align.CENTER
+    }
+
+    private val padL = dp(28f)
+    private val padR = dp(8f)
+    private val padT = dp(10f)
+    private val padB = dp(18f)
+
+    fun setData(data: List<UsageSnapshot>) {
+        points = data
+        invalidate()
+    }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        val left = padL
+        val top = padT
+        val right = width - padR
+        val bottom = height - padB
+        if (right <= left || bottom <= top) return
+
+        // Y gridlines + labels at 0 / 50 / 100%
+        for (pct in intArrayOf(0, 50, 100)) {
+            val y = bottom - (pct / 100f) * (bottom - top)
+            canvas.drawLine(left, y, right, y, gridPaint)
+            canvas.drawText("$pct", dp(4f), y + sp(3.5f), labelPaint)
+        }
+
+        val plottable = points.filter { it.sessionPct >= 0f || it.weeklyPct >= 0f }
+        if (plottable.size < 2) {
+            canvas.drawText(
+                "Collecting history… check back later",
+                (left + right) / 2f, (top + bottom) / 2f, emptyPaint
+            )
+            return
+        }
+
+        val tMin = plottable.first().epochMs
+        val tMax = plottable.last().epochMs
+        val tSpan = (tMax - tMin).coerceAtLeast(1L)
+
+        fun x(ms: Long) = left + (ms - tMin).toFloat() / tSpan * (right - left)
+        fun y(pct: Float) = bottom - (pct / 100f) * (bottom - top)
+
+        drawSeries(canvas, plottable, sessionPaint, ::x, ::y) { it.sessionPct }
+        drawSeries(canvas, plottable, weeklyPaint, ::x, ::y) { it.weeklyPct }
+
+        // X axis time labels (start … end)
+        val fmt = SimpleDateFormat("MMM d, h a", Locale.US)
+        labelPaint.textAlign = Paint.Align.LEFT
+        canvas.drawText(fmt.format(Date(tMin)), left, height - dp(4f), labelPaint)
+        labelPaint.textAlign = Paint.Align.RIGHT
+        canvas.drawText(fmt.format(Date(tMax)), right, height - dp(4f), labelPaint)
+        labelPaint.textAlign = Paint.Align.LEFT
+    }
+
+    private inline fun drawSeries(
+        canvas: Canvas,
+        data: List<UsageSnapshot>,
+        paint: Paint,
+        x: (Long) -> Float,
+        y: (Float) -> Float,
+        value: (UsageSnapshot) -> Float
+    ) {
+        val path = Path()
+        var penDown = false
+        var prevMs = 0L
+        for (p in data) {
+            val v = value(p)
+            if (v < 0f) { penDown = false; continue }
+            val px = x(p.epochMs); val py = y(v)
+            if (!penDown || p.epochMs - prevMs > GAP_MS) {
+                path.moveTo(px, py)
+            } else {
+                path.lineTo(px, py)
+            }
+            penDown = true
+            prevMs = p.epochMs
+        }
+        canvas.drawPath(path, paint)
+    }
+
+    private fun linePaint(c: Int) = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = c; strokeWidth = dp(2f); style = Paint.Style.STROKE
+        strokeJoin = Paint.Join.ROUND; strokeCap = Paint.Cap.ROUND
+    }
+
+    private fun dp(v: Float) = v * resources.displayMetrics.density
+    private fun sp(v: Float) = v * resources.displayMetrics.scaledDensity
+
+    companion object {
+        // Don't connect points separated by more than ~35 min (a missed refresh cycle or two).
+        private const val GAP_MS = 35 * 60 * 1000L
+    }
+}

app/src/main/java/me/khodak/claudeusage/LoginActivity.kt

@@ -8,7 +8,7 @@ import android.view.View
 import android.webkit.*
 import android.widget.Toast
 import androidx.appcompat.app.AppCompatActivity
-import kotlinx.coroutines.CoroutineScope
+import androidx.lifecycle.lifecycleScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import me.khodak.claudeusage.data.PreferencesManager
@@ -72,8 +72,8 @@ class LoginActivity : AppCompatActivity() {
             settings.apply {
                 javaScriptEnabled = true
                 domStorageEnabled = true
-                databaseEnabled = true
-                javaScriptCanOpenWindowsAutomatically = true
+                databaseEnabled = false
+                javaScriptCanOpenWindowsAutomatically = false
                 setSupportMultipleWindows(false)
                 // Standard Android Chrome UA — less suspicious than desktop
                 userAgentString = "Mozilla/5.0 (Linux; Android 13; Pixel 7) " +
@@ -145,7 +145,7 @@ class LoginActivity : AppCompatActivity() {
         UsageUpdateWorker.triggerImmediateRefresh(this)
         UsageUpdateWorker.schedulePeriodicRefresh(this)
 
-        CoroutineScope(Dispatchers.IO).launch {
+        lifecycleScope.launch(Dispatchers.IO) {
             try {
                 val data = UsageRepository(prefs).fetchUsage()
                 prefs.saveUsageData(data)

app/src/main/java/me/khodak/claudeusage/MainActivity.kt

@@ -1,10 +1,18 @@
 package me.khodak.claudeusage
 
+import android.Manifest
 import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
 import android.os.Bundle
 import android.view.View
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
+import androidx.core.content.ContextCompat
 import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import me.khodak.claudeusage.data.PreferencesManager
 import me.khodak.claudeusage.data.UsageData
@@ -19,6 +27,12 @@ class MainActivity : AppCompatActivity() {
     private lateinit var prefs: PreferencesManager
     private lateinit var repo: UsageRepository
 
+    private val notifPermLauncher =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { /* result handled silently */ }
+
+    /** Live refresh loop that runs only while the app is in the foreground. */
+    private var autoRefreshJob: Job? = null
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         binding = ActivityMainBinding.inflate(layoutInflater)
@@ -51,6 +65,8 @@ class MainActivity : AppCompatActivity() {
             })
         }
 
+        setupNotificationSettings()
+
         binding.btnDebug.setOnClickListener {
             if (binding.tvDebugInfo.visibility == android.view.View.GONE) {
                 binding.tvDebugInfo.text = repo.lastDebugInfo.ifBlank { "No debug info yet — tap Refresh first" }
@@ -65,28 +81,101 @@ class MainActivity : AppCompatActivity() {
 
     override fun onResume() {
         super.onResume()
-        val cached = prefs.getUsageData()
-        updateUI(cached)
-        if (prefs.isLoggedIn()) {
-            refreshUsage()
+        updateUI(prefs.getUsageData())  // show cached instantly — never a blank screen
+        if (prefs.isLoggedIn()) startAutoRefresh()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        autoRefreshJob?.cancel()
+    }
+
+    /** Refresh immediately on open, then every [REFRESH_INTERVAL_MS] while foregrounded. */
+    private fun startAutoRefresh() {
+        autoRefreshJob?.cancel()
+        autoRefreshJob = lifecycleScope.launch {
+            while (isActive) {
+                doRefresh(silent = true)
+                delay(REFRESH_INTERVAL_MS)
+            }
         }
     }
 
+    private fun setupNotificationSettings() {
+        binding.switchNotify.isChecked = prefs.isNotifyEnabled()
+        binding.sliderSession.value = prefs.getSessionThreshold().toFloat().coerceIn(50f, 100f)
+        binding.sliderWeekly.value = prefs.getWeeklyThreshold().toFloat().coerceIn(50f, 100f)
+        applyThresholdLabels()
+        applyNotifyControlsEnabled(prefs.isNotifyEnabled())
+
+        binding.switchNotify.setOnCheckedChangeListener { _, checked ->
+            prefs.setNotifyEnabled(checked)
+            applyNotifyControlsEnabled(checked)
+            if (checked) requestNotificationPermission()
+        }
+        binding.sliderSession.addOnChangeListener { _, value, _ ->
+            prefs.setSessionThreshold(value.toInt())
+            applyThresholdLabels()
+        }
+        binding.sliderWeekly.addOnChangeListener { _, value, _ ->
+            prefs.setWeeklyThreshold(value.toInt())
+            applyThresholdLabels()
+        }
+
+        // Alerts default on, so prompt for the runtime permission once on first launch
+        // (a user who never toggles the switch would otherwise never be asked).
+        if (prefs.isNotifyEnabled()) requestNotificationPermission()
+    }
+
+    private fun applyThresholdLabels() {
+        binding.tvSessionThreshLabel.text = "Session alert at ${prefs.getSessionThreshold()}%"
+        binding.tvWeeklyThreshLabel.text = "Weekly alert at ${prefs.getWeeklyThreshold()}%"
+    }
+
+    private fun applyNotifyControlsEnabled(enabled: Boolean) {
+        binding.sliderSession.isEnabled = enabled
+        binding.sliderWeekly.isEnabled = enabled
+        val alpha = if (enabled) 1f else 0.4f
+        binding.tvSessionThreshLabel.alpha = alpha
+        binding.tvWeeklyThreshLabel.alpha = alpha
+    }
+
+    private fun requestNotificationPermission() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) return
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS)
+            != PackageManager.PERMISSION_GRANTED
+        ) {
+            notifPermLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
+        }
+    }
+
+    /** Manual "Refresh Now" button — shows the spinner. */
     private fun refreshUsage() {
-        binding.btnRefresh.isEnabled = false
-        binding.progressIndicator.visibility = View.VISIBLE
-        lifecycleScope.launch {
-            val data = try {
-                repo.fetchUsage()
-            } catch (e: Exception) {
-                prefs.getUsageData()?.copy(errorMessage = "Network error")
-                    ?: UsageData(errorMessage = "Network error")
-            }
-            prefs.saveUsageData(data)
-            updateUI(data)
-            if (binding.tvDebugInfo.visibility == View.VISIBLE) {
-                binding.tvDebugInfo.text = repo.lastDebugInfo
-            }
+        lifecycleScope.launch { doRefresh(silent = false) }
+    }
+
+    private suspend fun doRefresh(silent: Boolean) {
+        if (!silent) {
+            binding.btnRefresh.isEnabled = false
+            binding.progressIndicator.visibility = View.VISIBLE
+        }
+        val fresh = try {
+            repo.fetchUsage()
+        } catch (e: Exception) {
+            if (e is kotlinx.coroutines.CancellationException) throw e
+            UsageData(errorMessage = "Network error")
+        }
+        // Preserve last-good data so a failed/partial fetch never blanks the UI or widget.
+        val merged = fresh.mergedWith(prefs.getUsageData())
+        prefs.saveUsageData(merged)
+        prefs.recordHistory(fresh)
+        Notifier.checkAndNotify(this, prefs, fresh)
+        updateUI(merged)
+        ClaudeUsageWidget.notifyDataChanged(this)  // opening the app refreshes the widget too
+        if (binding.tvDebugInfo.visibility == View.VISIBLE) {
+            binding.tvDebugInfo.text = repo.lastDebugInfo
+        }
+        if (!silent) {
             binding.btnRefresh.isEnabled = true
             binding.progressIndicator.visibility = View.GONE
         }
@@ -100,17 +189,37 @@ class MainActivity : AppCompatActivity() {
 
         if (!loggedIn || data == null) return
 
-        binding.progressBar.progress = data.progressPercent
+        // ── Peak-hours row ───────────────────────────────────────────────────
+        val peak = PeakHours.state()
+        binding.imgPeak.setColorFilter(if (peak.active) PEAK_ON else PEAK_OFF)
+        binding.tvPeak.setTextColor(if (peak.active) PEAK_ON else 0xFFAAAAAA.toInt())
+        binding.tvPeak.text = if (peak.active)
+            "🔥 Peak hours — ${peak.endsInLabel} · ${peak.windowLabel}"
+        else
+            "Off-peak · ${peak.windowLabel}"
 
+        // ── Session (5-hour) bar — no pace marker ────────────────────────────
+        binding.barSession.setImageBitmap(
+            BarRenderer.render(data.progressPercent, null, SESSION_FILL, null)
+        )
+
+        // ── Weekly (7-day) bar — single-color pace marker ────────────────────
         if (data.weeklyUtilization >= 0f) {
             val wPct = data.weeklyUtilization.toInt()
-            binding.progressBarWeekly.progress = wPct
+            val weeklyPace = PaceCalc.compute(data.weeklyUtilization, data.weeklyResetAtEpoch, PaceCalc.WEEKLY_WINDOW_MS)
+            binding.barWeekly.setImageBitmap(
+                BarRenderer.render(wPct, weeklyPace?.markerPct, WEEKLY_FILL, if (weeklyPace != null) MARKER_COLOR else null)
+            )
             binding.tvWeeklyUsage.text = "$wPct% this week"
         } else {
-            binding.progressBarWeekly.progress = 0
+            binding.barWeekly.setImageBitmap(BarRenderer.render(0, null, WEEKLY_FILL, null))
             binding.tvWeeklyUsage.text = "—"
         }
 
+        // Pace text removed per design — bars carry the signal.
+        binding.tvSessionPace.visibility = View.GONE
+        binding.tvWeeklyPace.visibility = View.GONE
+
         binding.tvUsage.text = when {
             data.fiveHourUtilization >= 0f -> {
                 val pct = data.fiveHourUtilization.toInt()
@@ -126,13 +235,15 @@ class MainActivity : AppCompatActivity() {
         }
 
         binding.tvReset.text = formatReset(data.effectiveResetEpoch)
-        binding.tvWeeklyReset.text = formatReset(data.weeklyResetAtEpoch)
+        binding.tvWeeklyReset.text = formatResetDay(data.weeklyResetAtEpoch)
         binding.tvUpdated.text = if (data.lastUpdated > 0)
             "Last updated: ${SimpleDateFormat("h:mm a, MMM d", Locale.US).format(Date(data.lastUpdated))}"
         else ""
 
         binding.tvError.text = data.errorMessage
         binding.tvError.visibility = if (data.errorMessage.isNotBlank()) View.VISIBLE else View.GONE
+
+        binding.historyChart.setData(prefs.getHistory())
     }
 
     private fun formatReset(epochMs: Long): String {
@@ -147,4 +258,23 @@ class MainActivity : AppCompatActivity() {
             else -> "Resets ${SimpleDateFormat("EEE", Locale.US).format(Date(epochMs))} $timeStr"
         }
     }
+
+    /** Weekly reset shown with the weekday name ("Resets Friday 3:00 PM"), never "tomorrow". */
+    private fun formatResetDay(epochMs: Long): String {
+        if (epochMs <= 0) return ""
+        if (epochMs <= System.currentTimeMillis()) return "Resets soon"
+        val day = SimpleDateFormat("EEEE", Locale.US).format(Date(epochMs))
+        val date = SimpleDateFormat("MMM d", Locale.US).format(Date(epochMs))
+        val timeStr = SimpleDateFormat("h:mm a", Locale.US).format(Date(epochMs))
+        return "Resets $day, $date · $timeStr"
+    }
+
+    companion object {
+        private const val REFRESH_INTERVAL_MS = 30_000L   // live refresh cadence while app is open
+        private const val SESSION_FILL = 0xFFCC785C.toInt()
+        private const val WEEKLY_FILL = 0xFF7B8FCC.toInt()
+        private const val MARKER_COLOR = 0xFFFFFFFF.toInt()   // single-color weekly pace marker
+        private const val PEAK_ON = 0xFFCC785C.toInt()
+        private const val PEAK_OFF = 0xFF666666.toInt()
+    }
 }

app/src/main/java/me/khodak/claudeusage/Notifier.kt

@@ -0,0 +1,115 @@
+package me.khodak.claudeusage
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import me.khodak.claudeusage.data.PreferencesManager
+import me.khodak.claudeusage.data.UsageData
+
+/**
+ * Posts a notification when session or weekly utilization crosses the user's threshold.
+ * Each metric fires at most once per limit window: we remember the reset-epoch we alerted
+ * for, and only re-arm when that window rolls over (epoch changes) — so the user isn't
+ * pinged every 5 minutes while sitting above the line.
+ */
+object Notifier {
+
+    private const val CHANNEL_ID = "usage_alerts"
+    private const val SESSION_NOTIF_ID = 2001
+    private const val WEEKLY_NOTIF_ID = 2002
+
+    fun checkAndNotify(context: Context, prefs: PreferencesManager, data: UsageData) {
+        if (!prefs.isNotifyEnabled()) return
+        val mgr = NotificationManagerCompat.from(context)
+        if (!mgr.areNotificationsEnabled()) return  // OS-level or runtime permission off
+        ensureChannel(context)
+
+        val session = data.fiveHourUtilization
+        if (session >= 0f) {
+            maybeFire(
+                context, mgr, prefs,
+                key = "session",
+                util = session.toInt(),
+                threshold = prefs.getSessionThreshold(),
+                resetEpoch = data.effectiveResetEpoch,
+                notifId = SESSION_NOTIF_ID,
+                title = "Session usage at ${session.toInt()}%",
+                body = "Your current 5-hour window is nearly used up."
+            )
+        }
+
+        val weekly = data.weeklyUtilization
+        if (weekly >= 0f) {
+            maybeFire(
+                context, mgr, prefs,
+                key = "weekly",
+                util = weekly.toInt(),
+                threshold = prefs.getWeeklyThreshold(),
+                resetEpoch = data.weeklyResetAtEpoch,
+                notifId = WEEKLY_NOTIF_ID,
+                title = "Weekly usage at ${weekly.toInt()}%",
+                body = "You're approaching your weekly Claude limit."
+            )
+        }
+    }
+
+    private fun maybeFire(
+        context: Context,
+        mgr: NotificationManagerCompat,
+        prefs: PreferencesManager,
+        key: String,
+        util: Int,
+        threshold: Int,
+        resetEpoch: Long,
+        notifId: Int,
+        title: String,
+        body: String
+    ) {
+        if (util < threshold) return
+        // Already alerted for this exact window? Skip. (resetEpoch<=0 means "unknown window" —
+        // fall back to a coarse marker so we still alert once instead of never.)
+        val windowMarker = if (resetEpoch > 0) resetEpoch else 1L
+        if (prefs.getNotifiedResetEpoch(key) == windowMarker) return
+
+        val notif = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(R.drawable.ic_claude_burst)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+            .setAutoCancel(true)
+            .setContentIntent(openAppIntent(context))
+            .build()
+
+        try {
+            mgr.notify(notifId, notif)
+            prefs.setNotifiedResetEpoch(key, windowMarker)
+        } catch (_: SecurityException) {
+            // Notifications revoked between the check and post — nothing to do.
+        }
+    }
+
+    private fun ensureChannel(context: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val mgr = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        if (mgr.getNotificationChannel(CHANNEL_ID) != null) return
+        mgr.createNotificationChannel(
+            NotificationChannel(
+                CHANNEL_ID, "Usage alerts", NotificationManager.IMPORTANCE_DEFAULT
+            ).apply { description = "Alerts when you approach your Claude usage limits" }
+        )
+    }
+
+    private fun openAppIntent(context: Context): PendingIntent {
+        val intent = Intent(context, MainActivity::class.java)
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        return PendingIntent.getActivity(
+            context, 0, intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+}

app/src/main/java/me/khodak/claudeusage/PaceCalc.kt

@@ -0,0 +1,65 @@
+package me.khodak.claudeusage
+
+/**
+ * Pace projection mirroring hamed-elfayome/Claude-Usage-Tracker's PaceStatus.
+ *
+ * Idea: if you keep your current burn rate, where do you land at reset?
+ *   projected = (usedPct / 100) / elapsedFraction
+ * The "where you should be right now" marker sits at elapsedFraction*100 on the bar —
+ * i.e. the position that finishes at exactly 100% by reset.
+ */
+object PaceCalc {
+
+    const val SESSION_WINDOW_MS = 5L * 60 * 60 * 1000          // 5 hours
+    const val WEEKLY_WINDOW_MS = 7L * 24 * 60 * 60 * 1000      // 7 days
+
+    // System-style tier colors (ARGB).
+    private const val GREEN = 0xFF34C759.toInt()
+    private const val TEAL = 0xFF30B0C7.toInt()
+    private const val YELLOW = 0xFFFFCC00.toInt()
+    private const val ORANGE = 0xFFFF9500.toInt()
+    private const val RED = 0xFFFF3B30.toInt()
+    private const val PURPLE = 0xFFAF52DE.toInt()
+
+    data class Pace(
+        val markerPct: Int,     // where you "should be" now (0..100)
+        val projected: Float,   // projected end-of-period fraction (1.0 == exactly 100%)
+        val tierColor: Int,     // ARGB color for the tier
+        val label: String       // short interpretation, e.g. "sustainable pace"
+    )
+
+    /**
+     * @param usedPct current utilization 0..100
+     * @param resetEpoch epoch millis when this window resets (period end)
+     * @param windowMs total length of the window
+     * @return Pace, or null if we can't meaningfully project yet
+     */
+    fun compute(
+        usedPct: Float,
+        resetEpoch: Long,
+        windowMs: Long,
+        now: Long = System.currentTimeMillis()
+    ): Pace? {
+        if (resetEpoch <= 0L || usedPct < 0f) return null
+        val start = resetEpoch - windowMs
+        val elapsed = now - start
+        val elapsedFraction = elapsed.toFloat() / windowMs.toFloat()
+        // Match reference: need >=3% elapsed and period not complete.
+        if (elapsedFraction < 0.03f || elapsedFraction >= 1.0f) return null
+
+        val markerPct = (elapsedFraction * 100f).toInt().coerceIn(0, 100)
+        if (usedPct == 0f) {
+            return Pace(markerPct, 0f, GREEN, "way under budget")
+        }
+        val projected = (usedPct / 100f) / elapsedFraction
+        val (color, label) = when {
+            projected < 0.50f -> GREEN to "way under budget"
+            projected < 0.75f -> TEAL to "sustainable pace"
+            projected < 0.90f -> YELLOW to "starting to push it"
+            projected < 1.00f -> ORANGE to "will likely hit limit"
+            projected < 1.20f -> RED to "on track to exceed"
+            else -> PURPLE to "burning way too fast"
+        }
+        return Pace(markerPct, projected, color, label)
+    }
+}

app/src/main/java/me/khodak/claudeusage/PeakHours.kt

@@ -0,0 +1,80 @@
+package me.khodak.claudeusage
+
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Date
+import java.util.GregorianCalendar
+import java.util.Locale
+import java.util.TimeZone
+import java.util.concurrent.TimeUnit
+
+/**
+ * Anthropic peak usage window, mirroring hamed-elfayome/Claude-Usage-Tracker's PeakHoursService:
+ * 5:00–11:00 AM America/Los_Angeles, Monday–Friday. Tokens burn faster during this window.
+ */
+object PeakHours {
+
+    private const val PEAK_START_HOUR = 5   // 5 AM PT inclusive
+    private const val PEAK_END_HOUR = 11    // 11 AM PT exclusive
+    private val PT: TimeZone = TimeZone.getTimeZone("America/Los_Angeles")
+
+    data class PeakState(
+        val active: Boolean,
+        val endsInLabel: String,   // e.g. "ends in 2h 14m" (only meaningful when active)
+        val windowLabel: String    // e.g. "5–11 AM PT · 8 AM–2 PM your time"
+    )
+
+    fun isPeak(now: Long = System.currentTimeMillis()): Boolean {
+        val cal = GregorianCalendar(PT).apply { timeInMillis = now }
+        val dow = cal.get(Calendar.DAY_OF_WEEK) // Sun=1 .. Sat=7
+        val weekday = dow in Calendar.MONDAY..Calendar.FRIDAY
+        val hour = cal.get(Calendar.HOUR_OF_DAY)
+        return weekday && hour in PEAK_START_HOUR until PEAK_END_HOUR
+    }
+
+    /** Epoch millis of 11:00 AM PT on the current PT day (peak window close). */
+    fun peakEndEpoch(now: Long = System.currentTimeMillis()): Long {
+        val cal = GregorianCalendar(PT).apply {
+            timeInMillis = now
+            set(Calendar.HOUR_OF_DAY, PEAK_END_HOUR)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }
+        return cal.timeInMillis
+    }
+
+    fun state(now: Long = System.currentTimeMillis()): PeakState {
+        val active = isPeak(now)
+        val endsIn = if (active) {
+            val rem = peakEndEpoch(now) - now
+            val h = TimeUnit.MILLISECONDS.toHours(rem)
+            val m = TimeUnit.MILLISECONDS.toMinutes(rem) % 60
+            if (h > 0) "ends in ${h}h ${m}m" else "ends in ${m}m"
+        } else ""
+        return PeakState(active, endsIn, localWindowString(now))
+    }
+
+    /** "5–11 AM PT · 8 AM–2 PM your time" — peak window translated to the device timezone. */
+    fun localWindowString(now: Long = System.currentTimeMillis()): String {
+        val local = TimeZone.getDefault()
+        if (local.id == PT.id) return "5–11 AM PT"
+        val startLocal = ptHourToLocal(PEAK_START_HOUR, now, local)
+        val endLocal = ptHourToLocal(PEAK_END_HOUR, now, local)
+        val fmt = SimpleDateFormat("h a", Locale.US).apply { timeZone = local }
+        val s = fmt.format(Date(startLocal)).replace(" ", " ")
+        val e = fmt.format(Date(endLocal)).replace(" ", " ")
+        return "5–11 AM PT · $s–$e your time"
+    }
+
+    private fun ptHourToLocal(ptHour: Int, now: Long, local: TimeZone): Long {
+        val cal = GregorianCalendar(PT).apply {
+            timeInMillis = now
+            set(Calendar.HOUR_OF_DAY, ptHour)
+            set(Calendar.MINUTE, 0)
+            set(Calendar.SECOND, 0)
+            set(Calendar.MILLISECOND, 0)
+        }
+        return cal.timeInMillis // absolute instant; formatting in `local` renders local wall time
+    }
+}

app/src/main/java/me/khodak/claudeusage/UsageRepository.kt

@@ -3,6 +3,7 @@ package me.khodak.claudeusage
 import android.util.Log
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import me.khodak.claudeusage.BuildConfig
 import me.khodak.claudeusage.data.PreferencesManager
 import me.khodak.claudeusage.data.UsageData
 import okhttp3.OkHttpClient
@@ -54,6 +55,7 @@ class UsageRepository(private val prefs: PreferencesManager) {
         if (orgId == null) return@withContext base.copy(errorMessage = "Can't reach claude.ai")
 
         if (orgUsageData?.hasRateLimitData == true) {
+            prefs.resetAuthFailCount()
             return@withContext base.copy(
                 messagesUsed = orgUsageData.messagesUsed,
                 messagesLimit = orgUsageData.messagesLimit,
@@ -67,15 +69,16 @@ class UsageRepository(private val prefs: PreferencesManager) {
             val usageUrl = "https://claude.ai/api/organizations/$orgId/usage"
             val resp = client.newCall(buildRequest(usageUrl, cookies)).execute()
             val code = resp.code
-            Log.d(TAG, "GET $usageUrl → $code")
+            if (BuildConfig.DEBUG) Log.d(TAG, "GET $usageUrl → $code")
             if (code == 401 || code == 403) {
                 prefs.clearSession()
                 return@withContext UsageData(errorMessage = "Session expired — please sign in again")
             }
             val body = resp.body?.string() ?: ""
-            debugBuf.append("$usageUrl\n→ $code: ${body.take(400)}\n\n")
+            if (BuildConfig.DEBUG) debugBuf.append("$usageUrl\n→ $code: ${body.take(400)}\n\n")
             val utilData = tryParseUtilizationBody(body)
             if (utilData != null) {
+                prefs.resetAuthFailCount()
                 return@withContext base.copy(
                     fiveHourUtilization = utilData.fiveHourUtilization,
                     weeklyUtilization = utilData.weeklyUtilization,
@@ -98,17 +101,24 @@ class UsageRepository(private val prefs: PreferencesManager) {
                 val req = buildRequest(url, cookies)
                 val resp = client.newCall(req).execute()
                 val code = resp.code
-                Log.d(TAG, "GET $url → $code")
+                if (BuildConfig.DEBUG) Log.d(TAG, "GET $url → $code")
 
                 if (code == 401 || code == 403) {
-                    prefs.clearSession()
-                    return@withContext UsageData(errorMessage = "Session expired — please sign in again")
+                    if (prefs.incAuthFailCount() >= AUTH_FAIL_LIMIT) {
+                        prefs.clearSession()
+                        prefs.resetAuthFailCount()
+                        return@withContext UsageData(errorMessage = "Session expired — please sign in again")
+                    }
+                    // Transient auth failure — keep showing last-good data instead of logging out.
+                    return@withContext base
                 }
 
                 val rateLimitData = extractRateLimitHeaders(resp.headers)
                 val body = resp.body?.string() ?: ""
-                debugBuf.append("$url\n→ $code: ${body.take(300)}\n\n")
-                Log.d(TAG, "Body: ${body.take(300)}")
+                if (BuildConfig.DEBUG) {
+                    debugBuf.append("$url\n→ $code: ${body.take(300)}\n\n")
+                    Log.d(TAG, "Body: ${body.take(300)}")
+                }
 
                 val parsed = tryParseUsageBody(body, rateLimitData)
                 if (parsed.hasRateLimitData) {
@@ -121,8 +131,8 @@ class UsageRepository(private val prefs: PreferencesManager) {
                     )
                 }
             } catch (e: Exception) {
-                Log.w(TAG, "Endpoint $url failed: ${e.message}")
-                debugBuf.append("$url\n→ ERROR: ${e.message}\n\n")
+                if (BuildConfig.DEBUG) Log.w(TAG, "Endpoint $url failed: ${e.message}")
+                if (BuildConfig.DEBUG) debugBuf.append("$url\n→ ERROR: ${e.message}\n\n")
             }
         }
 
@@ -131,7 +141,7 @@ class UsageRepository(private val prefs: PreferencesManager) {
             val req = buildRequest("https://claude.ai/api/me", cookies)
             val resp = client.newCall(req).execute()
             val body = resp.body?.string() ?: ""
-            debugBuf.append("https://claude.ai/api/me\n→ ${resp.code}: ${body.take(400)}\n\n")
+            if (BuildConfig.DEBUG) debugBuf.append("https://claude.ai/api/me\n→ ${resp.code}: ${body.take(400)}\n\n")
             if (resp.isSuccessful && body.isNotBlank() && !body.startsWith("<")) {
                 val json = JSONObject(body)
                 val parsed = tryParseOrgForUsage(json)
@@ -145,7 +155,7 @@ class UsageRepository(private val prefs: PreferencesManager) {
                 }
             }
         } catch (e: Exception) {
-            debugBuf.append("https://claude.ai/api/me → ERROR: ${e.message}\n\n")
+            if (BuildConfig.DEBUG) debugBuf.append("https://claude.ai/api/me → ERROR: ${e.message}\n\n")
         }
 
         // Step 4: try page HTML for __NEXT_DATA__
@@ -169,7 +179,7 @@ class UsageRepository(private val prefs: PreferencesManager) {
             val marker = """<script id="__NEXT_DATA__" type="application/json">"""
             val start = html.indexOf(marker)
             if (start < 0) {
-                debugBuf.append("HTML: no __NEXT_DATA__ found\n")
+                if (BuildConfig.DEBUG) debugBuf.append("HTML: no __NEXT_DATA__ found\n")
                 return null
             }
             val jsonStart = start + marker.length
@@ -177,10 +187,10 @@ class UsageRepository(private val prefs: PreferencesManager) {
             if (jsonEnd < 0) return null
             val nextData = JSONObject(html.substring(jsonStart, jsonEnd))
             val topKeys = nextData.keys().asSequence().toList()
-            debugBuf.append("HTML __NEXT_DATA__ top keys: $topKeys\n")
+            if (BuildConfig.DEBUG) debugBuf.append("HTML __NEXT_DATA__ top keys: $topKeys\n")
             tryExtractFromNextData(nextData)
         } catch (e: Exception) {
-            debugBuf.append("HTML scrape error: ${e.message}\n")
+            if (BuildConfig.DEBUG) debugBuf.append("HTML scrape error: ${e.message}\n")
             null
         }
     }
@@ -200,7 +210,7 @@ class UsageRepository(private val prefs: PreferencesManager) {
                 obj = (obj as? JSONObject)?.opt(key)
             }
             val o = obj as? JSONObject ?: continue
-            debugBuf.append("NextData at [${path.joinToString(".")}]: ${o.toString().take(300)}\n")
+            if (BuildConfig.DEBUG) debugBuf.append("NextData at [${path.joinToString(".")}]: ${o.toString().take(300)}\n")
             val usage = tryParseOrgForUsage(o) ?: tryParseUsageBody(o.toString(), UsageData())
             if (usage.hasRateLimitData) return usage
         }
@@ -210,9 +220,9 @@ class UsageRepository(private val prefs: PreferencesManager) {
     private fun fetchOrgInfo(cookies: String): Pair<String?, UsageData?> {
         return try {
             val resp = client.newCall(buildRequest("https://claude.ai/api/organizations", cookies)).execute()
-            Log.d(TAG, "Orgs → ${resp.code}")
+            if (BuildConfig.DEBUG) Log.d(TAG, "Orgs → ${resp.code}")
             val body = resp.body?.string() ?: return Pair(null, null)
-            debugBuf.append("https://claude.ai/api/organizations\n→ ${resp.code}: ${body.take(400)}\n\n")
+            if (BuildConfig.DEBUG) debugBuf.append("https://claude.ai/api/organizations\n→ ${resp.code}: ${body.take(400)}\n\n")
             if (body.isBlank() || body.startsWith("<")) return Pair(null, null)
             val arr = JSONArray(body)
             val org = arr.optJSONObject(0) ?: return Pair(null, null)
@@ -332,11 +342,14 @@ class UsageRepository(private val prefs: PreferencesManager) {
         .header("Accept", "application/json, */*")
         .header("Accept-Language", "en-US,en;q=0.9")
         .header("Referer", "https://claude.ai/")
-        .header("Cookie", cookies)
+        .header("Cookie", cookies.replace("\r", "").replace("\n", ""))
         .get()
         .build()
 
     companion object {
         private const val TAG = "UsageRepo"
+        // Clear the session only after this many consecutive 401/403s, so one transient
+        // auth failure (Cloudflare challenge, brief edge hiccup) doesn't sign the user out.
+        private const val AUTH_FAIL_LIMIT = 3
     }
 }

app/src/main/java/me/khodak/claudeusage/UsageUpdateWorker.kt

@@ -14,6 +14,7 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import me.khodak.claudeusage.data.PreferencesManager
+import java.util.concurrent.TimeUnit
 
 class UsageUpdateWorker(
     private val context: Context,
@@ -30,7 +31,10 @@ class UsageUpdateWorker(
             val animJob = launch { rotateRefreshIcon() }
             try {
                 val data = UsageRepository(prefs).fetchUsage()
-                prefs.saveUsageData(data)
+                // Preserve last-good data so a failed/partial fetch never blanks the widget.
+                prefs.saveUsageData(data.mergedWith(prefs.getUsageData()))
+                prefs.recordHistory(data)           // history records only fresh readings
+                Notifier.checkAndNotify(context, prefs, data)
             } catch (_: Exception) {}
             animJob.cancel()
             animJob.join()
@@ -77,21 +81,39 @@ class UsageUpdateWorker(
 
     companion object {
         private const val WORK_ONE_SHOT = "claude_oneshot"
+        private const val WORK_PERIODIC = "claude_periodic"
         private const val ALARM_CODE = 1001
         private const val INTERVAL_MS = 5 * 60 * 1000L
 
         fun schedulePeriodicRefresh(context: Context) {
+            // 5-min alarm for fast updates when the device is active/awake
             val am = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
             am.setAndAllowWhileIdle(
                 AlarmManager.ELAPSED_REALTIME_WAKEUP,
                 SystemClock.elapsedRealtime() + INTERVAL_MS,
                 alarmIntent(context)
             )
+            // WorkManager periodic as a Doze/background backup (Android 16 reliability).
+            // WorkManager uses JobScheduler which survives Doze; AlarmManager may be batched
+            // up to 75 min in Doze mode. KEEP = don't reset the 15-min timer on every alarm.
+            WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+                WORK_PERIODIC,
+                ExistingPeriodicWorkPolicy.KEEP,
+                PeriodicWorkRequestBuilder<UsageUpdateWorker>(15, TimeUnit.MINUTES)
+                    .setConstraints(
+                        Constraints.Builder()
+                            .setRequiredNetworkType(NetworkType.CONNECTED)
+                            .build()
+                    )
+                    .build()
+            )
         }
 
-        fun cancelPeriodicRefresh(context: Context) =
+        fun cancelPeriodicRefresh(context: Context) {
             (context.getSystemService(Context.ALARM_SERVICE) as AlarmManager)
                 .cancel(alarmIntent(context))
+            WorkManager.getInstance(context).cancelUniqueWork(WORK_PERIODIC)
+        }
 
         fun triggerImmediateRefresh(context: Context) {
             WorkManager.getInstance(context).enqueueUniqueWork(

app/src/main/java/me/khodak/claudeusage/data/PreferencesManager.kt

@@ -4,41 +4,33 @@ import android.content.Context
 import androidx.security.crypto.EncryptedSharedPreferences
 import androidx.security.crypto.MasterKey
 import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
 import java.util.Calendar
 
 class PreferencesManager(context: Context) {
 
     private val gson = Gson()
 
-    private val securePrefs = try {
-        val masterKey = MasterKey.Builder(context)
-            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-            .build()
-        EncryptedSharedPreferences.create(
-            context, "claude_secure", masterKey,
-            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
-            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
-        )
-    } catch (e: Exception) {
-        context.getSharedPreferences("claude_secure_fallback", Context.MODE_PRIVATE)
-    }
+    private var usingFallbackPrefs = false
+    private val securePrefs = createSecurePrefs(context, onFallback = { usingFallbackPrefs = true })
 
     private val prefs = context.getSharedPreferences("claude_prefs", Context.MODE_PRIVATE)
 
     fun saveCookies(cookies: String) {
-        securePrefs.edit().putString(KEY_COOKIES, cookies).apply()
-        // Plaintext backup — survives EncryptedSharedPreferences key rotation on reinstall
-        prefs.edit().putString(KEY_COOKIES_BACKUP, cookies).apply()
+        // Never store cookies in plain-text fallback prefs
+        if (usingFallbackPrefs) return
+        try {
+            securePrefs.edit().putString(KEY_COOKIES, cookies).apply()
+        } catch (_: Exception) {}
     }
 
-    fun getCookies(): String? =
+    fun getCookies(): String? = try {
         securePrefs.getString(KEY_COOKIES, null)
-            ?: prefs.getString(KEY_COOKIES_BACKUP, null)
+    } catch (_: Exception) { null }
 
     fun clearSession() {
-        securePrefs.edit().clear().apply()
-        prefs.edit().remove(KEY_ORG_ID).remove(KEY_SESSION_START)
-            .remove(KEY_COOKIES_BACKUP).apply()
+        try { securePrefs.edit().clear().apply() } catch (_: Exception) {}
+        prefs.edit().remove(KEY_ORG_ID).remove(KEY_SESSION_START).apply()
     }
 
     fun saveOrgId(id: String) = prefs.edit().putString(KEY_ORG_ID, id).apply()
@@ -82,13 +74,130 @@ class PreferencesManager(context: Context) {
 
     fun isLoggedIn(): Boolean = !getCookies().isNullOrBlank()
 
+    // Consecutive 401/403 counter — we only clear the session after several in a row, so a
+    // single transient auth failure (e.g. a Cloudflare challenge) doesn't log the user out.
+    fun getAuthFailCount(): Int = prefs.getInt(KEY_AUTH_FAILS, 0)
+    fun incAuthFailCount(): Int {
+        val n = getAuthFailCount() + 1
+        prefs.edit().putInt(KEY_AUTH_FAILS, n).apply()
+        return n
+    }
+    fun resetAuthFailCount() {
+        if (getAuthFailCount() != 0) prefs.edit().putInt(KEY_AUTH_FAILS, 0).apply()
+    }
+
+    // ── Usage history (for the in-app chart) ─────────────────────────────────
+
+    /**
+     * Append a history point if [data] carries a real utilization reading.
+     * De-duplicates rapid double-fires (manual refresh + background worker landing
+     * together) by skipping points within [MIN_HISTORY_GAP_MS] of the last one, and
+     * prunes anything older than [HISTORY_RETENTION_MS] / beyond [MAX_HISTORY_POINTS].
+     */
+    fun recordHistory(data: UsageData) {
+        if (data.fiveHourUtilization < 0f && data.weeklyUtilization < 0f) return
+        val now = System.currentTimeMillis()
+        val history = getHistory().toMutableList()
+        if (history.isNotEmpty() && now - history.last().epochMs < MIN_HISTORY_GAP_MS) {
+            history.removeAt(history.size - 1) // collapse near-simultaneous readings
+        }
+        history.add(
+            UsageSnapshot(
+                epochMs = now,
+                sessionPct = data.fiveHourUtilization,
+                weeklyPct = data.weeklyUtilization
+            )
+        )
+        val cutoff = now - HISTORY_RETENTION_MS
+        val pruned = history.filter { it.epochMs >= cutoff }
+            .takeLast(MAX_HISTORY_POINTS)
+        prefs.edit().putString(KEY_HISTORY, gson.toJson(pruned)).apply()
+    }
+
+    fun getHistory(): List<UsageSnapshot> {
+        val json = prefs.getString(KEY_HISTORY, null) ?: return emptyList()
+        return try {
+            val type = object : TypeToken<List<UsageSnapshot>>() {}.type
+            gson.fromJson<List<UsageSnapshot>>(json, type) ?: emptyList()
+        } catch (e: Exception) { emptyList() }
+    }
+
+    // ── Notification settings ────────────────────────────────────────────────
+
+    fun isNotifyEnabled(): Boolean = prefs.getBoolean(KEY_NOTIFY_ENABLED, true)
+    fun setNotifyEnabled(v: Boolean) = prefs.edit().putBoolean(KEY_NOTIFY_ENABLED, v).apply()
+
+    fun getSessionThreshold(): Int = prefs.getInt(KEY_NOTIFY_SESSION_PCT, 90)
+    fun setSessionThreshold(pct: Int) = prefs.edit().putInt(KEY_NOTIFY_SESSION_PCT, pct).apply()
+
+    fun getWeeklyThreshold(): Int = prefs.getInt(KEY_NOTIFY_WEEKLY_PCT, 85)
+    fun setWeeklyThreshold(pct: Int) = prefs.edit().putInt(KEY_NOTIFY_WEEKLY_PCT, pct).apply()
+
+    /**
+     * Tracks the reset-epoch a metric was last notified for, so we alert at most once
+     * per limit window. When the window rolls over (reset epoch changes), it re-arms.
+     */
+    fun getNotifiedResetEpoch(key: String): Long = prefs.getLong("notified_$key", 0L)
+    fun setNotifiedResetEpoch(key: String, epoch: Long) =
+        prefs.edit().putLong("notified_$key", epoch).apply()
+
     companion object {
         private const val KEY_COOKIES = "session_cookies"
-        private const val KEY_COOKIES_BACKUP = "session_cookies_backup"
         private const val KEY_ORG_ID = "org_id"
         private const val KEY_SESSION_START = "session_start"
         private const val KEY_USAGE_DATA = "usage_data"
         private const val KEY_ACTIVE_WEEK = "active_week"
         private const val KEY_ACTIVE_MASK = "active_mask"
+        private const val KEY_HISTORY = "usage_history"
+        private const val KEY_NOTIFY_ENABLED = "notify_enabled"
+        private const val KEY_NOTIFY_SESSION_PCT = "notify_session_pct"
+        private const val KEY_NOTIFY_WEEKLY_PCT = "notify_weekly_pct"
+        private const val KEY_AUTH_FAILS = "auth_fail_count"
+
+        private const val MIN_HISTORY_GAP_MS = 2 * 60 * 1000L      // collapse readings <2 min apart
+        private const val HISTORY_RETENTION_MS = 7 * 24 * 60 * 60 * 1000L  // keep 7 days
+        private const val MAX_HISTORY_POINTS = 600
+
+        fun createSecurePrefs(context: Context, onFallback: (() -> Unit)? = null): android.content.SharedPreferences {
+            return try {
+                buildEncryptedPrefs(context)
+            } catch (e: Exception) {
+                if (isKeyPermanentlyInvalidated(e)) {
+                    // Key permanently gone (biometric/PIN changed) — must wipe; user must re-login.
+                    try {
+                        context.deleteSharedPreferences("claude_secure")
+                        buildEncryptedPrefs(context)
+                    } catch (_: Exception) {
+                        onFallback?.invoke()
+                        context.getSharedPreferences("claude_secure_fallback", Context.MODE_PRIVATE)
+                    }
+                } else {
+                    // Transient failure (Keystore busy, cold boot, screen locked during BG work).
+                    // Do NOT delete the encrypted file — it will be readable next session.
+                    onFallback?.invoke()
+                    context.getSharedPreferences("claude_secure_fallback", Context.MODE_PRIVATE)
+                }
+            }
+        }
+
+        private fun buildEncryptedPrefs(context: Context): android.content.SharedPreferences {
+            val masterKey = MasterKey.Builder(context)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .build()
+            return EncryptedSharedPreferences.create(
+                context, "claude_secure", masterKey,
+                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+            )
+        }
+
+        private fun isKeyPermanentlyInvalidated(e: Exception): Boolean {
+            var t: Throwable? = e
+            while (t != null) {
+                if (t is android.security.keystore.KeyPermanentlyInvalidatedException) return true
+                t = t.cause
+            }
+            return false
+        }
     }
 }

app/src/main/java/me/khodak/claudeusage/data/UsageData.kt

@@ -49,4 +49,36 @@ data class UsageData(
         resetAtEpoch > 0 -> resetAtEpoch
         else -> -1L
     }
+
+    /** True if this fetch produced any usable usage reading at all. */
+    val hasAnyReading: Boolean get() =
+        fiveHourUtilization >= 0f || weeklyUtilization >= 0f || hasRateLimitData
+
+    /**
+     * Merge a fresh fetch over the last cached reading so a failed or partial refresh never
+     * blanks the widget. If this fetch got nothing usable, the whole previous snapshot is kept
+     * (with its original timestamp, so the footer shows the data's true age). Otherwise each
+     * metric this fetch didn't return falls back to the previous value.
+     */
+    fun mergedWith(previous: UsageData?): UsageData {
+        if (previous == null || !previous.hasAnyReading) return this
+        if (!hasAnyReading) {
+            // Keep last-good data; only carry this attempt's login/session context forward.
+            return previous.copy(
+                isLoggedIn = isLoggedIn,
+                sessionStartEpoch = if (sessionStartEpoch > 0) sessionStartEpoch else previous.sessionStartEpoch,
+                weeklyActiveDaysMask = if (weeklyActiveDaysMask != 0) weeklyActiveDaysMask else previous.weeklyActiveDaysMask
+            )
+        }
+        return copy(
+            fiveHourUtilization = if (fiveHourUtilization >= 0f) fiveHourUtilization else previous.fiveHourUtilization,
+            utilizationResetAtEpoch = if (fiveHourUtilization >= 0f) utilizationResetAtEpoch else previous.utilizationResetAtEpoch,
+            weeklyUtilization = if (weeklyUtilization >= 0f) weeklyUtilization else previous.weeklyUtilization,
+            weeklyResetAtEpoch = if (weeklyUtilization >= 0f) weeklyResetAtEpoch else previous.weeklyResetAtEpoch,
+            messagesLimit = if (messagesLimit > 0) messagesLimit else previous.messagesLimit,
+            messagesUsed = if (messagesUsed >= 0) messagesUsed else previous.messagesUsed,
+            messagesRemaining = if (messagesRemaining >= 0) messagesRemaining else previous.messagesRemaining,
+            resetAtEpoch = if (resetAtEpoch > 0) resetAtEpoch else previous.resetAtEpoch
+        )
+    }
 }

app/src/main/java/me/khodak/claudeusage/data/UsageSnapshot.kt

@@ -0,0 +1,11 @@
+package me.khodak.claudeusage.data
+
+/**
+ * A single point-in-time reading of usage, stored for the in-app history chart.
+ * Percentages are 0-100; -1 means "no reading for this metric at this time".
+ */
+data class UsageSnapshot(
+    val epochMs: Long = 0L,
+    val sessionPct: Float = -1f,
+    val weeklyPct: Float = -1f
+)

app/src/main/res/drawable/ic_claude_burst.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Claude "sunburst" mark. Drawn in white; tinted at runtime via setColorFilter
+     (calm #666666, peak #CC785C). -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:strokeColor="#FFFFFF"
+        android:strokeWidth="1.7"
+        android:strokeLineCap="round"
+        android:pathData="
+            M12,3 L12,7
+            M12,17 L12,21
+            M3,12 L7,12
+            M17,12 L21,12
+            M5.6,5.6 L8.4,8.4
+            M15.6,15.6 L18.4,18.4
+            M18.4,5.6 L15.6,8.4
+            M8.4,15.6 L5.6,18.4
+            M12,4.5 L12,6.2
+            M12,17.8 L12,19.5
+            M4.5,12 L6.2,12
+            M17.8,12 L19.5,12" />
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,9.6 a2.4,2.4 0 1,0 0.01,0 z" />
+</vector>

app/src/main/res/layout/activity_main.xml

@@ -92,6 +92,33 @@
                 android:background="@drawable/widget_background"
                 android:padding="20dp">
 
+                <!-- Peak-hours row -->
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:gravity="center_vertical"
+                    android:layout_marginBottom="14dp">
+
+                    <ImageView
+                        android:id="@+id/imgPeak"
+                        android:layout_width="20dp"
+                        android:layout_height="20dp"
+                        android:layout_marginEnd="8dp"
+                        android:src="@drawable/ic_claude_burst"
+                        android:contentDescription="Peak hours" />
+
+                    <TextView
+                        android:id="@+id/tvPeak"
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:text=""
+                        android:textColor="#AAAAAA"
+                        android:textSize="12sp" />
+
+                </LinearLayout>
+
                 <TextView
                     android:layout_width="wrap_content"
                     android:layout_height="wrap_content"
@@ -110,16 +137,24 @@
                     android:textSize="20sp"
                     android:textStyle="bold" />
 
-                <ProgressBar
-                    android:id="@+id/progressBar"
-                    style="@android:style/Widget.ProgressBar.Horizontal"
+                <ImageView
+                    android:id="@+id/barSession"
                     android:layout_width="match_parent"
-                    android:layout_height="8dp"
+                    android:layout_height="9dp"
                     android:layout_marginTop="12dp"
-                    android:max="100"
-                    android:progress="0"
-                    android:progressTint="#CC785C"
-                    android:progressBackgroundTint="#3A3A3A" />
+                    android:scaleType="fitXY"
+                    android:adjustViewBounds="false"
+                    android:contentDescription="Session usage bar" />
+
+                <TextView
+                    android:id="@+id/tvSessionPace"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="6dp"
+                    android:text=""
+                    android:textColor="#AAAAAA"
+                    android:textSize="13sp"
+                    android:textStyle="bold" />
 
                 <TextView
                     android:id="@+id/tvReset"
@@ -148,16 +183,24 @@
                     android:textSize="16sp"
                     android:textStyle="bold" />
 
-                <ProgressBar
-                    android:id="@+id/progressBarWeekly"
-                    style="@android:style/Widget.ProgressBar.Horizontal"
+                <ImageView
+                    android:id="@+id/barWeekly"
                     android:layout_width="match_parent"
-                    android:layout_height="8dp"
+                    android:layout_height="9dp"
                     android:layout_marginTop="8dp"
-                    android:max="100"
-                    android:progress="0"
-                    android:progressTint="#7B8FCC"
-                    android:progressBackgroundTint="#3A3A3A" />
+                    android:scaleType="fitXY"
+                    android:adjustViewBounds="false"
+                    android:contentDescription="Weekly usage bar" />
+
+                <TextView
+                    android:id="@+id/tvWeeklyPace"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="6dp"
+                    android:text=""
+                    android:textColor="#AAAAAA"
+                    android:textSize="13sp"
+                    android:textStyle="bold" />
 
                 <TextView
                     android:id="@+id/tvWeeklyReset"
@@ -186,6 +229,137 @@
 
             </LinearLayout>
 
+            <!-- History card -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:background="@drawable/widget_background"
+                android:padding="20dp"
+                android:layout_marginTop="16dp">
+
+                <TextView
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:text="HISTORY"
+                    android:textColor="#888888"
+                    android:textSize="11sp"
+                    android:letterSpacing="0.1" />
+
+                <me.khodak.claudeusage.HistoryChartView
+                    android:id="@+id/historyChart"
+                    android:layout_width="match_parent"
+                    android:layout_height="140dp"
+                    android:layout_marginTop="12dp" />
+
+                <!-- Legend -->
+                <LinearLayout
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:layout_marginTop="10dp"
+                    android:gravity="center_vertical">
+
+                    <View
+                        android:layout_width="12dp"
+                        android:layout_height="3dp"
+                        android:background="#CC785C" />
+
+                    <TextView
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginStart="6dp"
+                        android:layout_marginEnd="16dp"
+                        android:text="Session"
+                        android:textColor="#AAAAAA"
+                        android:textSize="12sp" />
+
+                    <View
+                        android:layout_width="12dp"
+                        android:layout_height="3dp"
+                        android:background="#7B8FCC" />
+
+                    <TextView
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:layout_marginStart="6dp"
+                        android:text="Weekly"
+                        android:textColor="#AAAAAA"
+                        android:textSize="12sp" />
+
+                </LinearLayout>
+
+            </LinearLayout>
+
+            <!-- Notifications card -->
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:background="@drawable/widget_background"
+                android:padding="20dp"
+                android:layout_marginTop="16dp">
+
+                <LinearLayout
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:orientation="horizontal"
+                    android:gravity="center_vertical">
+
+                    <TextView
+                        android:layout_width="0dp"
+                        android:layout_height="wrap_content"
+                        android:layout_weight="1"
+                        android:text="USAGE ALERTS"
+                        android:textColor="#888888"
+                        android:textSize="11sp"
+                        android:letterSpacing="0.1" />
+
+                    <com.google.android.material.switchmaterial.SwitchMaterial
+                        android:id="@+id/switchNotify"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content" />
+
+                </LinearLayout>
+
+                <TextView
+                    android:id="@+id/tvSessionThreshLabel"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="14dp"
+                    android:text="Session alert at 90%"
+                    android:textColor="#FFFFFF"
+                    android:textSize="14sp" />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/sliderSession"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="50"
+                    android:valueTo="100"
+                    android:stepSize="5"
+                    android:value="90" />
+
+                <TextView
+                    android:id="@+id/tvWeeklyThreshLabel"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginTop="4dp"
+                    android:text="Weekly alert at 85%"
+                    android:textColor="#FFFFFF"
+                    android:textSize="14sp" />
+
+                <com.google.android.material.slider.Slider
+                    android:id="@+id/sliderWeekly"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:valueFrom="50"
+                    android:valueTo="100"
+                    android:stepSize="5"
+                    android:value="85" />
+
+            </LinearLayout>
+
             <Button
                 android:id="@+id/btnRefresh"
                 android:layout_width="match_parent"

app/src/main/res/layout/widget_layout.xml

@@ -23,10 +23,28 @@
             android:textSize="13sp"
             android:textStyle="bold" />
 
+        <ImageView
+            android:id="@+id/img_peak"
+            android:layout_width="16dp"
+            android:layout_height="16dp"
+            android:layout_marginEnd="4dp"
+            android:src="@drawable/ic_claude_burst"
+            android:contentDescription="Peak hours" />
+
+        <TextView
+            android:id="@+id/tv_peak"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginEnd="6dp"
+            android:text=""
+            android:textColor="#CC785C"
+            android:textSize="9sp"
+            android:textStyle="bold" />
+
         <ImageButton
             android:id="@+id/btn_refresh"
-            android:layout_width="24dp"
-            android:layout_height="24dp"
+            android:layout_width="32dp"
+            android:layout_height="32dp"
             android:src="@android:drawable/ic_menu_rotate"
             android:background="@android:color/transparent"
             android:tint="#999999"
@@ -54,7 +72,7 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text="SESSION"
-            android:textColor="#555555"
+            android:textColor="#FFFFFF"
             android:textSize="9sp"
             android:textStyle="bold" />
 
@@ -69,16 +87,14 @@
 
     </LinearLayout>
 
-    <ProgressBar
-        android:id="@+id/progress_bar"
-        style="@android:style/Widget.ProgressBar.Horizontal"
+    <ImageView
+        android:id="@+id/bar_session"
         android:layout_width="match_parent"
-        android:layout_height="5dp"
+        android:layout_height="6dp"
         android:layout_marginTop="5dp"
-        android:max="100"
-        android:progress="0"
-        android:progressTint="#CC785C"
-        android:progressBackgroundTint="#252525" />
+        android:scaleType="fitXY"
+        android:adjustViewBounds="false"
+        android:contentDescription="Session usage bar" />
 
     <TextView
         android:id="@+id/tv_session_label"
@@ -86,8 +102,9 @@
         android:layout_height="wrap_content"
         android:layout_marginTop="3dp"
         android:text=""
-        android:textColor="#666666"
-        android:textSize="9sp" />
+        android:textColor="#FFFFFF"
+        android:textSize="11sp"
+        android:textStyle="bold" />
 
     <!-- 7-day window bar -->
     <LinearLayout
@@ -102,7 +119,7 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text="WEEKLY"
-            android:textColor="#555555"
+            android:textColor="#FFFFFF"
             android:textSize="9sp"
             android:textStyle="bold" />
 
@@ -117,16 +134,14 @@
 
     </LinearLayout>
 
-    <ProgressBar
-        android:id="@+id/progress_bar_weekly"
-        style="@android:style/Widget.ProgressBar.Horizontal"
+    <ImageView
+        android:id="@+id/bar_weekly"
         android:layout_width="match_parent"
-        android:layout_height="5dp"
+        android:layout_height="6dp"
         android:layout_marginTop="5dp"
-        android:max="100"
-        android:progress="0"
-        android:progressTint="#7B8FCC"
-        android:progressBackgroundTint="#252525" />
+        android:scaleType="fitXY"
+        android:adjustViewBounds="false"
+        android:contentDescription="Weekly usage bar" />
 
     <TextView
         android:id="@+id/tv_weekly_label"
@@ -134,8 +149,9 @@
         android:layout_height="wrap_content"
         android:layout_marginTop="3dp"
         android:text=""
-        android:textColor="#666666"
-        android:textSize="9sp" />
+        android:textColor="#FFFFFF"
+        android:textSize="11sp"
+        android:textStyle="bold" />
 
     <!-- Footer -->
     <LinearLayout
@@ -151,8 +167,9 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text=""
-            android:textColor="#CC785C"
+            android:textColor="#FFFFFF"
             android:textSize="9sp"
+            android:textStyle="bold"
             android:singleLine="true"
             android:ellipsize="end" />
 
@@ -161,8 +178,9 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text=""
-            android:textColor="#444444"
-            android:textSize="9sp" />
+            android:textColor="#FFFFFF"
+            android:textSize="9sp"
+            android:textStyle="bold" />
 
     </LinearLayout>
 

app/src/main/res/layout/widget_layout_small.xml

@@ -23,10 +23,18 @@
             android:textSize="11sp"
             android:textStyle="bold" />
 
+        <ImageView
+            android:id="@+id/img_peak"
+            android:layout_width="14dp"
+            android:layout_height="14dp"
+            android:layout_marginEnd="6dp"
+            android:src="@drawable/ic_claude_burst"
+            android:contentDescription="Peak hours" />
+
         <ImageButton
             android:id="@+id/btn_refresh"
-            android:layout_width="20dp"
-            android:layout_height="20dp"
+            android:layout_width="28dp"
+            android:layout_height="28dp"
             android:src="@android:drawable/ic_menu_rotate"
             android:background="@android:color/transparent"
             android:contentDescription="Refresh" />
@@ -46,7 +54,7 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text="SESSION"
-            android:textColor="#555555"
+            android:textColor="#FFFFFF"
             android:textSize="8sp"
             android:textStyle="bold" />
 
@@ -65,21 +73,20 @@
             android:layout_height="wrap_content"
             android:layout_marginStart="6dp"
             android:text=""
-            android:textColor="#555555"
-            android:textSize="8sp" />
+            android:textColor="#FFFFFF"
+            android:textSize="10sp"
+            android:textStyle="bold" />
 
     </LinearLayout>
 
-    <ProgressBar
-        android:id="@+id/progress_bar"
-        style="@android:style/Widget.ProgressBar.Horizontal"
+    <ImageView
+        android:id="@+id/bar_session"
         android:layout_width="match_parent"
-        android:layout_height="4dp"
+        android:layout_height="5dp"
         android:layout_marginTop="3dp"
-        android:max="100"
-        android:progress="0"
-        android:progressTint="#CC785C"
-        android:progressBackgroundTint="#252525" />
+        android:scaleType="fitXY"
+        android:adjustViewBounds="false"
+        android:contentDescription="Session usage bar" />
 
     <!-- 7-DAY row -->
     <LinearLayout
@@ -94,7 +101,7 @@
             android:layout_height="wrap_content"
             android:layout_weight="1"
             android:text="WEEKLY"
-            android:textColor="#555555"
+            android:textColor="#FFFFFF"
             android:textSize="8sp"
             android:textStyle="bold" />
 
@@ -113,21 +120,20 @@
             android:layout_height="wrap_content"
             android:layout_marginStart="6dp"
             android:text=""
-            android:textColor="#555555"
-            android:textSize="8sp" />
+            android:textColor="#FFFFFF"
+            android:textSize="10sp"
+            android:textStyle="bold" />
 
     </LinearLayout>
 
-    <ProgressBar
-        android:id="@+id/progress_bar_weekly"
-        style="@android:style/Widget.ProgressBar.Horizontal"
+    <ImageView
+        android:id="@+id/bar_weekly"
         android:layout_width="match_parent"
-        android:layout_height="4dp"
+        android:layout_height="5dp"
         android:layout_marginTop="3dp"
-        android:max="100"
-        android:progress="0"
-        android:progressTint="#7B8FCC"
-        android:progressBackgroundTint="#252525" />
+        android:scaleType="fitXY"
+        android:adjustViewBounds="false"
+        android:contentDescription="Weekly usage bar" />
 
     <TextView
         android:id="@+id/tv_status"
@@ -135,8 +141,9 @@
         android:layout_height="wrap_content"
         android:layout_marginTop="4dp"
         android:text=""
-        android:textColor="#CC785C"
+        android:textColor="#FFFFFF"
         android:textSize="8sp"
+        android:textStyle="bold"
         android:maxLines="1" />
 
 </LinearLayout>

app/src/main/res/xml/network_security_config.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="false">
+        <trust-anchors>
+            <certificates src="system" />
+        </trust-anchors>
+    </base-config>
+</network-security-config>

app/src/main/res/xml/widget_info.xml

@@ -11,6 +11,6 @@
     android:resizeMode="horizontal|vertical"
     android:updatePeriodMillis="1800000"
     android:initialLayout="@layout/widget_layout"
-    android:widgetCategory="home_screen|keyguard"
+    android:widgetCategory="home_screen"
     android:description="@string/widget_description"
     android:previewLayout="@layout/widget_layout" />

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,5 @@
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -1,13 +1,34 @@
-#!/bin/sh
-#
-# Gradle start up script for UN*X
-#
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -48,16 +69,23 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
         JAVACMD="$JAVA_HOME/jre/sh/java"
     else
         JAVACMD="$JAVA_HOME/bin/java"
     fi
     if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME"
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
     fi
 else
     JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH."
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -81,14 +109,68 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
     JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
 fi
 
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
 # Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$@"
+if $JAVACMD --add-opens java.base/java.lang=ALL-UNNAMED -version ; then
+    DEFAULT_JVM_OPTS="--add-opens java.base/java.lang=ALL-UNNAMED $DEFAULT_JVM_OPTS"
+fi
+
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega