feat: MiniMax weekly quota integration across all views

Parse weekly limit fields from MiniMax API (current_weekly_total_count,
current_weekly_usage_count, weekly_start_time, weekly_end_time,
weekly_remains_time) - only available for accounts purchased from
2026-03-23 onwards.

- Add weekly fields to MiniMaxModelRemain, MiniMaxModelQuota types
- DB migration adds 7 weekly columns to minimax_model_values
- Store persists and reads weekly data alongside interval data
- Dashboard shows weekly quota cards (3 per row, 2 rows for 6 quotas)
- Menubar shows compact weekly KPIs (Wkly M*, Wkly Img, Wkly Spch)
- Usage graphs include weekly series as separate chart lines
- Logging history includes weekly columns
- Cycle overview cross-quota entries include weekly data
- Session detail shows weekly peak, start, delta
- Usage insights add 5-Hour vs Weekly ratio insight
- Graceful degradation for pre-March-23 accounts (no weekly data)

Author: prakersh

CLAUDE.md

@@ -33,9 +33,12 @@ internal/
 
 ## Operations
 
+**Always use `app.sh` for build and test - never run `go build` or `go test` directly.**
+
 ```bash
-./app.sh --build            # Build before running
-./app.sh --test             # go test -race -cover ./...
+./app.sh --build            # Build production binary
+./app.sh --test             # Run all tests with race detection and coverage
+./app.sh --smoke            # Quick validation: vet + build check + short tests
 go test -race ./... && go vet ./...   # Pre-commit (mandatory)
 ```
 

VERSION

@@ -1 +1 @@
-2.11.35
+2.11.36

internal/api/minimax_types.go

@@ -22,6 +22,13 @@ type MiniMaxModelRemain struct {
 	CurrentIntervalTotalCount int         `json:"current_interval_total_count"`
 	// Despite the field name, this endpoint returns remaining requests.
 	CurrentIntervalUsageCount int `json:"current_interval_usage_count"`
+
+	// Weekly quota fields - only present for accounts purchased from 2026-03-23 onwards.
+	CurrentWeeklyTotalCount int         `json:"current_weekly_total_count"`
+	CurrentWeeklyUsageCount int         `json:"current_weekly_usage_count"`
+	WeeklyStartTime         interface{} `json:"weekly_start_time"`
+	WeeklyEndTime           interface{} `json:"weekly_end_time"`
+	WeeklyRemainsTime       int64       `json:"weekly_remains_time"`
 }
 
 // MiniMaxRemainsResponse is the full API response.
@@ -41,6 +48,17 @@ type MiniMaxModelQuota struct {
 	WindowStart    *time.Time
 	WindowEnd      *time.Time
 	TimeUntilReset time.Duration
+
+	// Weekly quota - zero values when not available (pre-March-23 accounts).
+	WeeklyTotal          int
+	WeeklyRemain         int
+	WeeklyUsed           int
+	WeeklyUsedPercent    float64
+	WeeklyResetAt        *time.Time
+	WeeklyWindowStart    *time.Time
+	WeeklyWindowEnd      *time.Time
+	WeeklyTimeUntilReset time.Duration
+	HasWeeklyQuota       bool
 }
 
 // MiniMaxSnapshot is a point-in-time capture.
@@ -97,15 +115,24 @@ func (s *MiniMaxSnapshot) MergedQuota() *MiniMaxModelQuota {
 	}
 	first := s.Models[0]
 	return &MiniMaxModelQuota{
-		ModelName:      "MiniMax Coding Plan",
-		Total:          first.Total,
-		Remain:         first.Remain,
-		Used:           first.Used,
-		UsedPercent:    first.UsedPercent,
-		ResetAt:        first.ResetAt,
-		WindowStart:    first.WindowStart,
-		WindowEnd:      first.WindowEnd,
-		TimeUntilReset: first.TimeUntilReset,
+		ModelName:            "MiniMax Coding Plan",
+		Total:                first.Total,
+		Remain:               first.Remain,
+		Used:                 first.Used,
+		UsedPercent:          first.UsedPercent,
+		ResetAt:              first.ResetAt,
+		WindowStart:          first.WindowStart,
+		WindowEnd:            first.WindowEnd,
+		TimeUntilReset:       first.TimeUntilReset,
+		HasWeeklyQuota:       first.HasWeeklyQuota,
+		WeeklyTotal:          first.WeeklyTotal,
+		WeeklyRemain:         first.WeeklyRemain,
+		WeeklyUsed:           first.WeeklyUsed,
+		WeeklyUsedPercent:    first.WeeklyUsedPercent,
+		WeeklyResetAt:        first.WeeklyResetAt,
+		WeeklyWindowStart:    first.WeeklyWindowStart,
+		WeeklyWindowEnd:      first.WeeklyWindowEnd,
+		WeeklyTimeUntilReset: first.WeeklyTimeUntilReset,
 	}
 }
 
@@ -229,7 +256,7 @@ func (r MiniMaxRemainsResponse) ToSnapshot(capturedAt time.Time) *MiniMaxSnapsho
 			usedPercent = (float64(used) / float64(total)) * 100
 		}
 
-		snapshot.Models = append(snapshot.Models, MiniMaxModelQuota{
+		quota := MiniMaxModelQuota{
 			ModelName:      model.ModelName,
 			Total:          total,
 			Remain:         remain,
@@ -239,7 +266,38 @@ func (r MiniMaxRemainsResponse) ToSnapshot(capturedAt time.Time) *MiniMaxSnapsho
 			WindowStart:    windowStart,
 			WindowEnd:      windowEnd,
 			TimeUntilReset: untilReset,
-		})
+		}
+
+		// Parse weekly quota fields if present.
+		if model.CurrentWeeklyTotalCount > 0 || model.CurrentWeeklyUsageCount > 0 {
+			quota.HasWeeklyQuota = true
+			quota.WeeklyTotal = model.CurrentWeeklyTotalCount
+			// Same naming quirk: current_weekly_usage_count is actually remaining.
+			quota.WeeklyRemain = model.CurrentWeeklyUsageCount
+			quota.WeeklyUsed = quota.WeeklyTotal - quota.WeeklyRemain
+			if quota.WeeklyUsed < 0 {
+				quota.WeeklyUsed = 0
+			}
+			if quota.WeeklyTotal > 0 {
+				quota.WeeklyUsedPercent = (float64(quota.WeeklyUsed) / float64(quota.WeeklyTotal)) * 100
+			}
+			quota.WeeklyWindowStart = parseMiniMaxTimestamp(model.WeeklyStartTime)
+			quota.WeeklyWindowEnd = parseMiniMaxTimestamp(model.WeeklyEndTime)
+			if model.WeeklyRemainsTime > 0 {
+				d := time.Duration(model.WeeklyRemainsTime) * time.Millisecond
+				wr := snapshot.CapturedAt.Add(d)
+				quota.WeeklyResetAt = &wr
+				quota.WeeklyTimeUntilReset = d
+			} else if quota.WeeklyWindowEnd != nil {
+				quota.WeeklyResetAt = quota.WeeklyWindowEnd
+				quota.WeeklyTimeUntilReset = quota.WeeklyWindowEnd.Sub(snapshot.CapturedAt)
+				if quota.WeeklyTimeUntilReset < 0 {
+					quota.WeeklyTimeUntilReset = 0
+				}
+			}
+		}
+
+		snapshot.Models = append(snapshot.Models, quota)
 	}
 
 	if raw, err := json.Marshal(r); err == nil {

internal/store/minimax_store.go

@@ -66,10 +66,22 @@ func (s *Store) InsertMiniMaxSnapshot(snapshot *api.MiniMaxSnapshot, accountID i
 			windowEndVal = m.WindowEnd.Format(time.RFC3339Nano)
 		}
 
+		var weeklyResetAtVal, weeklyWindowStartVal, weeklyWindowEndVal interface{}
+		if m.WeeklyResetAt != nil {
+			weeklyResetAtVal = m.WeeklyResetAt.Format(time.RFC3339Nano)
+		}
+		if m.WeeklyWindowStart != nil {
+			weeklyWindowStartVal = m.WeeklyWindowStart.Format(time.RFC3339Nano)
+		}
+		if m.WeeklyWindowEnd != nil {
+			weeklyWindowEndVal = m.WeeklyWindowEnd.Format(time.RFC3339Nano)
+		}
+
 		_, err := tx.Exec(
 			`INSERT INTO minimax_model_values
-			(snapshot_id, model_name, total, remain, used, used_percent, reset_at, window_start, window_end)
-			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			(snapshot_id, model_name, total, remain, used, used_percent, reset_at, window_start, window_end,
+			 weekly_total, weekly_remain, weekly_used, weekly_used_percent, weekly_reset_at, weekly_window_start, weekly_window_end)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 			snapshotID,
 			m.ModelName,
 			m.Total,
@@ -79,6 +91,13 @@ func (s *Store) InsertMiniMaxSnapshot(snapshot *api.MiniMaxSnapshot, accountID i
 			resetAtVal,
 			windowStartVal,
 			windowEndVal,
+			m.WeeklyTotal,
+			m.WeeklyRemain,
+			m.WeeklyUsed,
+			m.WeeklyUsedPercent,
+			weeklyResetAtVal,
+			weeklyWindowStartVal,
+			weeklyWindowEndVal,
 		)
 		if err != nil {
 			return 0, fmt.Errorf("failed to insert minimax model value %s: %w", m.ModelName, err)
@@ -181,7 +200,8 @@ func (s *Store) QueryMiniMaxRange(start, end time.Time, accountID int64, limit .
 
 func (s *Store) queryMiniMaxModelValues(snapshotID int64) ([]api.MiniMaxModelQuota, error) {
 	rows, err := s.db.Query(
-		`SELECT model_name, total, remain, used, used_percent, reset_at, window_start, window_end
+		`SELECT model_name, total, remain, used, used_percent, reset_at, window_start, window_end,
+		 weekly_total, weekly_remain, weekly_used, weekly_used_percent, weekly_reset_at, weekly_window_start, weekly_window_end
 		FROM minimax_model_values WHERE snapshot_id = ? ORDER BY model_name`,
 		snapshotID,
 	)
@@ -194,7 +214,9 @@ func (s *Store) queryMiniMaxModelValues(snapshotID int64) ([]api.MiniMaxModelQuo
 	for rows.Next() {
 		var m api.MiniMaxModelQuota
 		var resetAt, windowStart, windowEnd sql.NullString
-		if err := rows.Scan(&m.ModelName, &m.Total, &m.Remain, &m.Used, &m.UsedPercent, &resetAt, &windowStart, &windowEnd); err != nil {
+		var weeklyResetAt, weeklyWindowStart, weeklyWindowEnd sql.NullString
+		if err := rows.Scan(&m.ModelName, &m.Total, &m.Remain, &m.Used, &m.UsedPercent, &resetAt, &windowStart, &windowEnd,
+			&m.WeeklyTotal, &m.WeeklyRemain, &m.WeeklyUsed, &m.WeeklyUsedPercent, &weeklyResetAt, &weeklyWindowStart, &weeklyWindowEnd); err != nil {
 			return nil, fmt.Errorf("failed to scan minimax model value: %w", err)
 		}
 		if resetAt.Valid {
@@ -213,6 +235,26 @@ func (s *Store) queryMiniMaxModelValues(snapshotID int64) ([]api.MiniMaxModelQuo
 			t, _ := time.Parse(time.RFC3339Nano, windowEnd.String)
 			m.WindowEnd = &t
 		}
+		// Weekly quota fields.
+		if m.WeeklyTotal > 0 || m.WeeklyUsed > 0 {
+			m.HasWeeklyQuota = true
+		}
+		if weeklyResetAt.Valid {
+			t, _ := time.Parse(time.RFC3339Nano, weeklyResetAt.String)
+			m.WeeklyResetAt = &t
+			m.WeeklyTimeUntilReset = time.Until(t)
+			if m.WeeklyTimeUntilReset < 0 {
+				m.WeeklyTimeUntilReset = 0
+			}
+		}
+		if weeklyWindowStart.Valid {
+			t, _ := time.Parse(time.RFC3339Nano, weeklyWindowStart.String)
+			m.WeeklyWindowStart = &t
+		}
+		if weeklyWindowEnd.Valid {
+			t, _ := time.Parse(time.RFC3339Nano, weeklyWindowEnd.String)
+			m.WeeklyWindowEnd = &t
+		}
 		models = append(models, m)
 	}
 	return models, rows.Err()
@@ -525,7 +567,7 @@ func (s *Store) minimaxCrossQuotasAt(referenceTime time.Time, accountID int64) (
 		return nil, nil
 	}
 
-	entries := make([]CrossQuotaEntry, 0, len(snap.Models))
+	entries := make([]CrossQuotaEntry, 0, len(snap.Models)*2)
 	for _, model := range snap.Models {
 		entries = append(entries, CrossQuotaEntry{
 			Name:         model.ModelName,
@@ -535,6 +577,16 @@ func (s *Store) minimaxCrossQuotasAt(referenceTime time.Time, accountID int64) (
 			StartPercent: 0,
 			Delta:        model.UsedPercent,
 		})
+		if model.HasWeeklyQuota && (model.WeeklyTotal > 0 || model.WeeklyUsed > 0) {
+			entries = append(entries, CrossQuotaEntry{
+				Name:         "weekly_" + model.ModelName,
+				Value:        float64(model.WeeklyUsed),
+				Limit:        float64(model.WeeklyTotal),
+				Percent:      model.WeeklyUsedPercent,
+				StartPercent: 0,
+				Delta:        model.WeeklyUsedPercent,
+			})
+		}
 	}
 	sort.Slice(entries, func(i, j int) bool { return entries[i].Name < entries[j].Name })
 	return entries, nil

internal/store/store.go

@@ -868,6 +868,25 @@ func (s *Store) migrateSchema() error {
 		}
 	}
 
+	// Add weekly quota columns to minimax_model_values.
+	// Only accounts purchased from 2026-03-23 onwards have weekly limits.
+	for _, col := range []string{
+		"weekly_total INTEGER NOT NULL DEFAULT 0",
+		"weekly_remain INTEGER NOT NULL DEFAULT 0",
+		"weekly_used INTEGER NOT NULL DEFAULT 0",
+		"weekly_used_percent REAL NOT NULL DEFAULT 0",
+		"weekly_reset_at TEXT",
+		"weekly_window_start TEXT",
+		"weekly_window_end TEXT",
+	} {
+		if _, err := s.db.Exec(`ALTER TABLE minimax_model_values ADD COLUMN ` + col); err != nil {
+			if !strings.Contains(err.Error(), "duplicate column name") &&
+				!strings.Contains(err.Error(), "no such table") {
+				return fmt.Errorf("failed to add weekly column to minimax_model_values: %w", err)
+			}
+		}
+	}
+
 	return nil
 }