Release CodeVetter 1.1.13

Author: Assistant

README.md

@@ -44,6 +44,21 @@ The product should prefer narrow, evidence-backed loops over broad "code intelli
 
 ## Installation
 
+### Ask Your Agent To Install
+
+Give your coding agent this prompt:
+
+```text
+Install CodeVetter from the latest GitHub release:
+https://github.com/sarthak-fleet/CodeVetter/releases/latest
+
+Detect this machine's OS and CPU architecture, download the matching CodeVetter app archive, verify the release asset hash when available, extract it, install CodeVetter.app into /Applications on macOS, remove the quarantine attribute if needed, and launch the app once to verify it starts.
+```
+
+Prefer the app archive over the DMG until the macOS bundle is Developer ID signed and notarized.
+
+### Development Install
+
 ```bash
 # Clone and install dependencies (uses npm workspaces)
 git clone https://github.com/sarthak-fleet/CodeVetter.git

apps/desktop/docs/RELEASING.md

@@ -25,12 +25,13 @@
    npm run tauri:build
    ```
 
-3. The build produces (in `src-tauri/target/release/bundle/`):
-   - `CodeVetter_x.y.z_aarch64.dmg` — installer for manual download
+3. The release workflow produces:
    - `CodeVetter.app.tar.gz` — compressed app bundle for auto-update
    - `CodeVetter.app.tar.gz.sig` — signature file
    - `latest.json` — update manifest (contains version, download URL, signature)
 
+   Prefer the app archive for manual installs until the macOS bundle is Developer ID signed and notarized. Unsigned or ad-hoc signed DMGs fail Gatekeeper for new installs.
+
 4. Create a GitHub release at `sarthak-fleet/CodeVetter`:
    - Tag: `v{x.y.z}`
    - Upload all build artifacts including `latest.json`

apps/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code-reviewer/desktop",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "private": true,
   "scripts": {
     "dev": "lsof -ti:1420 | xargs kill -9 2>/dev/null; vite",

apps/desktop/src-tauri/tauri.conf.json

@@ -2,7 +2,7 @@
   "$schema": "https://raw.githubusercontent.com/tauri-apps/tauri/dev/crates/tauri-utils/schema.json",
   "identifier": "com.codevetter.desktop",
   "productName": "CodeVetter",
-  "version": "1.1.12",
+  "version": "1.1.13",
   "build": {
     "beforeDevCommand": "npm run dev",
     "beforeBuildCommand": "npm run build",

apps/desktop/src/lib/use-tray-monitor.ts

@@ -1,14 +1,18 @@
 import { useEffect, useRef } from "react";
 
 import {
+  type AccountUsage,
+  checkAccountUsage,
   checkLiveUsage,
   getPreference,
   getTokenUsageStats,
   isTauriAvailable,
   listProviderAccounts,
+  listSessions,
   type LiveUsageResult,
   type ProviderAccount,
   sendTrayNotification,
+  type SessionRow,
   setTrayMenu,
   setTrayText,
 } from "@/lib/tauri-ipc";
@@ -24,6 +28,11 @@ const SUPPORTED_PROVIDERS = new Set(["anthropic", "openai", "google"]);
 // notification. Each (accountId × window × threshold) only fires once per app
 // process — the ref below holds the latest threshold we've already notified.
 const NOTIFY_THRESHOLDS = [75, 90, 100];
+const WEEKLY_USAGE_NOTIFY_THRESHOLDS = [90, 100];
+const WEEKLY_PACE_AHEAD_NOTIFY_PCT = 50;
+const MIN_WEEKLY_PACE_NOTIFY_PCT = 10;
+const SESSION_USAGE_NOTIFY_THRESHOLD = 90;
+const ACTIVE_SESSION_WINDOW_MS = 15 * 60 * 1000;
 
 function formatTokens(n: number): string {
   if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(2)}B`;
@@ -110,6 +119,60 @@ function buildTrayLine(
   return `${label}${plan} — ${live.status ?? "ok"}`;
 }
 
+function inferContextLimitTokens(model: string | null, agentType: string): number | null {
+  const normalized = (model ?? "").toLowerCase();
+
+  if (normalized.includes("claude") || agentType === "claude-code") {
+    return 200_000;
+  }
+  if (normalized.includes("gpt-4.1") || normalized.includes("gpt-4o")) {
+    return 128_000;
+  }
+  if (
+    normalized === "o3" ||
+    normalized.startsWith("o3-") ||
+    normalized === "o4-mini"
+  ) {
+    return 200_000;
+  }
+  if (normalized.includes("gemini-1.5") || normalized.includes("gemini-2")) {
+    return 1_000_000;
+  }
+
+  return null;
+}
+
+function sessionUsagePct(session: SessionRow): number | null {
+  const limit = inferContextLimitTokens(session.model_used, session.agent_type);
+  if (!limit) return null;
+  const total = session.total_input_tokens + session.total_output_tokens;
+  if (total <= 0) return null;
+  return (total / limit) * 100;
+}
+
+function sessionLabel(session: SessionRow): string {
+  if (session.cwd) {
+    const parts = session.cwd.split("/").filter(Boolean);
+    const name = parts.at(-1);
+    if (name) return name;
+  }
+  if (session.slug) return session.slug;
+  return `${session.agent_type} session`;
+}
+
+function isRecentlyActiveSession(session: SessionRow): boolean {
+  if (!session.last_message) return false;
+  const lastMessageMs = new Date(session.last_message).getTime();
+  if (!Number.isFinite(lastMessageMs)) return false;
+  return Date.now() - lastMessageMs <= ACTIVE_SESSION_WINDOW_MS;
+}
+
+function weeklyPaceAheadPct(usage: AccountUsage): number | null {
+  if (usage.week_pct == null || usage.expected_pct <= 0) return null;
+  if (usage.week_pct < MIN_WEEKLY_PACE_NOTIFY_PCT) return null;
+  return ((usage.week_pct - usage.expected_pct) / usage.expected_pct) * 100;
+}
+
 async function loadCadenceSecs(): Promise<number> {
   if (!isTauriAvailable()) return DEFAULT_CADENCE_SECS;
   try {
@@ -133,6 +196,16 @@ async function loadNotificationsEnabled(): Promise<boolean> {
   }
 }
 
+async function loadSessionNotificationsEnabled(): Promise<boolean> {
+  if (!isTauriAvailable()) return true;
+  try {
+    const raw = await getPreference("notify_session_usage_thresholds");
+    return raw !== "false";
+  } catch {
+    return true;
+  }
+}
+
 /**
  * Mounts a single global tray monitor at App level so the menu-bar icon stays
  * fresh regardless of which page the user is on. Polls accounts + live usage
@@ -142,6 +215,9 @@ export function useTrayMonitor(): void {
   // Persist last-notified threshold per accountId across re-renders so we
   // don't re-fire the same notification on every poll.
   const lastNotifiedRef = useRef<Record<string, number>>({});
+  const weeklyUsageNotifiedRef = useRef<Record<string, number>>({});
+  const weeklyPaceNotifiedRef = useRef<Record<string, number>>({});
+  const sessionUsageNotifiedRef = useRef<Record<string, number>>({});
 
   useEffect(() => {
     if (!isTauriAvailable()) return;
@@ -170,6 +246,14 @@ export function useTrayMonitor(): void {
           if (r.status === "fulfilled") liveMap[supported[i].id] = r.value;
         });
 
+        const usageResults = await Promise.allSettled(
+          accounts.map((a) => checkAccountUsage(a.id))
+        );
+        const usageMap: Record<string, AccountUsage> = {};
+        usageResults.forEach((r, i) => {
+          if (r.status === "fulfilled") usageMap[accounts[i].id] = r.value;
+        });
+
         // Today's tokens (separate query; cheap local SQLite call).
         const tokenUsage = await getTokenUsageStats().catch(() => null);
 
@@ -207,6 +291,68 @@ export function useTrayMonitor(): void {
               `Worst window utilization: ${Math.round(pct)}%`
             ).catch(() => {});
           }
+
+          for (const a of accounts) {
+            const usage = usageMap[a.id];
+            if (!usage) continue;
+            const label = a.name || a.provider;
+
+            if (usage.week_pct != null) {
+              const crossed = WEEKLY_USAGE_NOTIFY_THRESHOLDS.filter(
+                (t) => usage.week_pct != null && usage.week_pct >= t
+              ).pop();
+              const last = weeklyUsageNotifiedRef.current[a.id] ?? 0;
+              if (crossed && crossed > last) {
+                weeklyUsageNotifiedRef.current[a.id] = crossed;
+                const verb = crossed >= 100 ? "over weekly baseline" : `at ${crossed}% weekly`;
+                await sendTrayNotification(
+                  `${label} ${verb}`,
+                  `Weekly usage is ${Math.round(usage.week_pct)}% of baseline.`
+                ).catch(() => {});
+              }
+            }
+
+            const aheadPct = weeklyPaceAheadPct(usage);
+            const paceLast = weeklyPaceNotifiedRef.current[a.id] ?? 0;
+            if (
+              aheadPct != null &&
+              aheadPct >= WEEKLY_PACE_AHEAD_NOTIFY_PCT &&
+              paceLast < WEEKLY_PACE_AHEAD_NOTIFY_PCT
+            ) {
+              weeklyPaceNotifiedRef.current[a.id] = WEEKLY_PACE_AHEAD_NOTIFY_PCT;
+              await sendTrayNotification(
+                `${label} is ahead of weekly pace`,
+                `Usage is ${Math.round(aheadPct)}% ahead of schedule (${Math.round(
+                  usage.week_pct ?? 0
+                )}% used vs ${Math.round(usage.expected_pct)}% expected).`
+              ).catch(() => {});
+            }
+          }
+        }
+
+        // ── Session context-usage notifications ────────────────────────
+        const sessionNotifyEnabled = await loadSessionNotificationsEnabled();
+        if (sessionNotifyEnabled) {
+          const sessions = await listSessions(undefined, undefined, 25).catch(
+            () => [] as SessionRow[]
+          );
+          for (const session of sessions) {
+            if (!isRecentlyActiveSession(session)) continue;
+            const pct = sessionUsagePct(session);
+            if (pct == null || pct < SESSION_USAGE_NOTIFY_THRESHOLD) continue;
+            const last = sessionUsageNotifiedRef.current[session.id] ?? 0;
+            if (last >= SESSION_USAGE_NOTIFY_THRESHOLD) continue;
+            sessionUsageNotifiedRef.current[session.id] =
+              SESSION_USAGE_NOTIFY_THRESHOLD;
+
+            const total = session.total_input_tokens + session.total_output_tokens;
+            await sendTrayNotification(
+              `${sessionLabel(session)} is near its session limit`,
+              `${Math.round(pct)}% used (${formatTokens(total)} tokens) for ${
+                session.model_used ?? session.agent_type
+              }.`
+            ).catch(() => {});
+          }
         }
       } catch {
         // Swallow — never let a failed poll break the loop.

apps/desktop/src/pages/Settings.tsx

@@ -573,6 +573,7 @@ export default function Settings() {
   const [notifyTaskComplete, toggleNotifyTaskComplete] = useBoolPref("notify_task_complete", false);
   const [notificationSound, toggleNotificationSound] = useBoolPref("notification_sound", true);
   const [notifyQuotaThresholds, toggleNotifyQuotaThresholds] = useBoolPref("notify_quota_thresholds", true);
+  const [notifySessionUsageThresholds, toggleNotifySessionUsageThresholds] = useBoolPref("notify_session_usage_thresholds", true);
 
   // Menu-bar tray
   const [trayCadence, setTrayCadence] = usePref("tray_refresh_cadence_secs", "120");
@@ -873,13 +874,22 @@ export default function Settings() {
 
               <Toggle
                 label="Provider Quota Thresholds"
-                description="Notify when any provider window crosses 75%, 90%, or 100% utilization."
+                description="Notify when provider windows, weekly baselines, or weekly pace cross important thresholds."
                 enabled={notifyQuotaThresholds}
                 onToggle={toggleNotifyQuotaThresholds}
               />
 
               <Divider />
 
+              <Toggle
+                label="Session Usage Thresholds"
+                description="Notify when an active session crosses 90% of its inferred context window."
+                enabled={notifySessionUsageThresholds}
+                onToggle={toggleNotifySessionUsageThresholds}
+              />
+
+              <Divider />
+
               <Toggle
                 label="Notification Sounds"
                 description="Play a short tone for success, error, and info events."