standout 0.5.25 → 0.5.26

package/dist/cursor.d.ts

@@ -11,6 +11,8 @@ export interface CursorStats {
         total: number;
     };
     models: string[];
+    model_session_counts: Record<string, number>;
+    tool_call_counts: Record<string, number>;
     hour_buckets: number[];
     weekend_ratio: number;
     languages: Record<string, number>;
@@ -18,15 +20,12 @@ export interface CursorStats {
     prompt_frequency: PromptFrequency[];
     exchanges: ConversationExchange[];
     interaction: InteractionSignals;
-    monthly_buckets: {
-        month: string;
-        sessions: number;
-        duration_hours: number;
-        input_tokens: number;
-        output_tokens: number;
-        cache_tokens: number;
-        primary_model: string | null;
-    }[];
+    total_input_tokens: number;
+    total_output_tokens: number;
+    total_cache_read_tokens: number;
+    total_cache_write_tokens: number;
+    tokens_estimated: true;
+    monthly_buckets: CursorMonthlyBucket[];
     all_time?: {
         total_sessions: number;
         active_days: number;
@@ -37,18 +36,22 @@ export interface CursorStats {
         total_output_tokens: number;
         total_cache_read_tokens: number;
         total_cache_write_tokens: number;
-        monthly_buckets: {
-            month: string;
-            sessions: number;
-            duration_hours: number;
-            input_tokens: number;
-            output_tokens: number;
-            cache_tokens: number;
-            primary_model: string | null;
-        }[];
+        monthly_buckets: CursorMonthlyBucket[];
     };
 }
+interface CursorMonthlyBucket {
+    month: string;
+    sessions: number;
+    duration_hours: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    cache_tokens: number;
+    primary_model: string | null;
+}
 export declare function gatherCursor(opts?: {
     dbPath?: string;
     windowStartMs?: number;
 }): Promise<CursorStats | null>;
+export {};

package/dist/cursor.js

@@ -16,6 +16,27 @@ const CORRECTION_RE = /\b(no|nope|actually|wrong|incorrect|instead|revert|undo|d
 // Mirrors ai-usage.ts — cannot import (would create a module cycle).
 const TRIVIAL_ASK_RE = /^(y|n|yes|yep|yeah|ya|ok|okay|k|sure|go|go ahead|do it|continue|please continue|next|thanks|thank you|thx|ty|nice|cool|perfect|great|good|done|ship it|lgtm|👍|\.|\?)\b[\s.!]*$/i;
 const SHELL_COMMAND_RE = /^(npx|npm|pnpm|yarn|bun|git|cd|ls|cat|node|python|pip|brew|sudo|docker|curl|echo|mkdir|rm|mv|cp)\b/i;
+// Cursor persists no usable token/cost data locally — bubble `tokenCount` is
+// zeroed and composer `usageData` is empty. We estimate both from active
+// duration using the economics of our Claude Code cohort (Cursor runs the same
+// Claude models). The per-hour token split is calibrated so that, priced at the
+// generic retail fallback rate, it totals ~$20/active-hour — the cohort's
+// blended retail $/hour. Surfaced with an "estimated" disclaimer on the cards.
+const CURSOR_EST_TOKENS_PER_HOUR = {
+    input: 38_000,
+    output: 110_000,
+    cacheRead: 24_750_000,
+    cacheWrite: 750_000,
+};
+function estimateCursorTokens(hours) {
+    const h = hours > 0 ? hours : 0;
+    return {
+        input: Math.round(CURSOR_EST_TOKENS_PER_HOUR.input * h),
+        output: Math.round(CURSOR_EST_TOKENS_PER_HOUR.output * h),
+        cacheRead: Math.round(CURSOR_EST_TOKENS_PER_HOUR.cacheRead * h),
+        cacheWrite: Math.round(CURSOR_EST_TOKENS_PER_HOUR.cacheWrite * h),
+    };
+}
 function isLowSignalAsk(sample) {
     const t = sample.trim();
     return t.length < 12 || TRIVIAL_ASK_RE.test(t) || SHELL_COMMAND_RE.test(t);
@@ -159,13 +180,20 @@ async function readState(dbPath, Driver) {
                     continue;
                 const composerId = parsed.composerId ??
                     row.key.slice("composerData:".length);
+                const modelConfig = parsed.modelConfig && typeof parsed.modelConfig === "object"
+                    ? parsed.modelConfig
+                    : null;
+                const modelName = (modelConfig && typeof modelConfig.modelName === "string"
+                    ? modelConfig.modelName
+                    : null) ??
+                    (typeof parsed.latestSelectedModel === "string"
+                        ? parsed.latestSelectedModel
+                        : null);
                 composers.set(composerId, {
                     composerId,
                     createdAt: numericTs(parsed.createdAt),
                     lastUpdatedAt: numericTs(parsed.lastUpdatedAt),
-                    modelConfig: typeof parsed.latestSelectedModel === "string"
-                        ? parsed.latestSelectedModel
-                        : null,
+                    modelName: modelName && modelName !== "default" ? modelName : null,
                 });
             }
             if (rows.length < PAGE)
@@ -196,12 +224,22 @@ async function readState(dbPath, Driver) {
                 const text = typeof parsed.text === "string" ? parsed.text : null;
                 const createdAt = numericTs(parsed.createdAt);
                 const filePaths = extractFilePaths(parsed);
+                const tool = parsed.toolFormerData && typeof parsed.toolFormerData === "object"
+                    ? parsed.toolFormerData
+                    : null;
+                const toolName = tool &&
+                    (typeof tool.name === "string"
+                        ? tool.name
+                        : typeof tool.tool === "string"
+                            ? tool.tool
+                            : null);
                 bubbles.set(parts[2], {
                     conversationId,
                     type,
                     text,
                     createdAt,
                     filePaths,
+                    toolName: toolName || null,
                 });
             }
             if (rows.length < PAGE)
@@ -294,10 +332,10 @@ export async function gatherCursor(opts = {}) {
         first_session: allTime.first_session,
         last_session: allTime.last_session,
         total_duration_hours: allTime.total_duration_hours,
-        total_input_tokens: 0,
-        total_output_tokens: 0,
-        total_cache_read_tokens: 0,
-        total_cache_write_tokens: 0,
+        total_input_tokens: allTime.total_input_tokens,
+        total_output_tokens: allTime.total_output_tokens,
+        total_cache_read_tokens: allTime.total_cache_read_tokens,
+        total_cache_write_tokens: allTime.total_cache_write_tokens,
         monthly_buckets: allTime.monthly_buckets,
     };
     return stats.total_sessions > 0 || allTime.total_sessions > 0 ? stats : null;
@@ -335,6 +373,9 @@ function finalize(raw, opts = {}) {
     let userTurns = 0;
     let correctionTurns = 0;
     let countedSessions = 0;
+    let toolCalls = 0;
+    const modelSessionCounts = {};
+    const toolCallCounts = {};
     const monthly = new Map();
     for (const [composerId, composer] of raw.composers.entries()) {
         const entry = sessionBubbles.get(composerId);
@@ -366,6 +407,10 @@ function finalize(raw, opts = {}) {
         month.sessions += 1;
         month.durationMs += durationMs;
         monthly.set(monthKey, month);
+        if (composer.modelName) {
+            modelSessionCounts[composer.modelName] =
+                (modelSessionCounts[composer.modelName] ?? 0) + 1;
+        }
         for (const ts of windowTs) {
             const d = new Date(ts);
             if (Number.isNaN(d.getTime()))
@@ -385,6 +430,11 @@ function finalize(raw, opts = {}) {
                     if (allFiles.size < MAX_FILE_PATHS)
                         allFiles.add(fp);
                 }
+                if (bubble.toolName) {
+                    toolCalls += 1;
+                    toolCallCounts[bubble.toolName] =
+                        (toolCallCounts[bubble.toolName] ?? 0) + 1;
+                }
             }
             const windowSamples = windowBubbles
                 .filter((bubble) => bubble.type === 1 && bubble.text)
@@ -443,6 +493,34 @@ function finalize(raw, opts = {}) {
             languages[lang] = (languages[lang] || 0) + 1;
         }
     }
+    const monthlyBuckets = [...monthly.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([month, b]) => {
+        const hours = +(b.durationMs / 1000 / 3600).toFixed(1);
+        const est = estimateCursorTokens(hours);
+        return {
+            month,
+            sessions: b.sessions,
+            duration_hours: hours,
+            input_tokens: est.input,
+            output_tokens: est.output,
+            cache_read_tokens: est.cacheRead,
+            cache_write_tokens: est.cacheWrite,
+            cache_tokens: est.cacheRead + est.cacheWrite,
+            primary_model: null,
+        };
+    });
+    // Totals are the exact sum of the (rounded-per-month) buckets so the top-level
+    // figures metrics.ts reads match what the card sums from monthly_buckets.
+    const totals = monthlyBuckets.reduce((acc, b) => ({
+        input: acc.input + b.input_tokens,
+        output: acc.output + b.output_tokens,
+        cacheRead: acc.cacheRead + b.cache_read_tokens,
+        cacheWrite: acc.cacheWrite + b.cache_write_tokens,
+    }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+    const models = Object.entries(modelSessionCounts)
+        .sort((a, b) => b[1] - a[1])
+        .map(([model]) => model);
     return {
         total_sessions: countedSessions,
         active_days: activeDays.size,
@@ -458,7 +536,9 @@ function finalize(raw, opts = {}) {
             assistant: assistantTotal,
             total: userTotal + assistantTotal,
         },
-        models: [],
+        models,
+        model_session_counts: modelSessionCounts,
+        tool_call_counts: toolCallCounts,
         hour_buckets: hourBuckets,
         weekend_ratio: totalEvents > 0 ? +(weekendEvents / totalEvents).toFixed(2) : 0,
         languages,
@@ -470,18 +550,13 @@ function finalize(raw, opts = {}) {
         interaction: {
             user_turns: userTurns,
             correction_turns: correctionTurns,
-            tool_calls: 0,
+            tool_calls: toolCalls,
         },
-        monthly_buckets: [...monthly.entries()]
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([month, b]) => ({
-            month,
-            sessions: b.sessions,
-            duration_hours: +(b.durationMs / 1000 / 3600).toFixed(1),
-            input_tokens: 0,
-            output_tokens: 0,
-            cache_tokens: 0,
-            primary_model: null,
-        })),
+        total_input_tokens: totals.input,
+        total_output_tokens: totals.output,
+        total_cache_read_tokens: totals.cacheRead,
+        total_cache_write_tokens: totals.cacheWrite,
+        tokens_estimated: true,
+        monthly_buckets: monthlyBuckets,
     };
 }

package/dist/wrapped/aggregate.js

@@ -495,13 +495,15 @@ function computeTokens(aiUsage) {
     const cacheTotal = (b) => b.cache_read_tokens !== undefined || b.cache_write_tokens !== undefined
         ? (b.cache_read_tokens ?? 0) + (b.cache_write_tokens ?? 0)
         : (b.cache_tokens ?? 0);
-    // Cursor exposes no reliable token counts — flag it so the card can say so,
-    // but only when it was actually used in THIS window (the card is "last 30
-    // days"). All-time Cursor sessions don't count: claiming "Cursor used too" when
-    // they haven't opened it in a month is just wrong.
+    // Cursor exposes no local token counts — its tokens/cost are estimated from
+    // active time (see cursor.ts). Flag it so the card discloses the estimate, but
+    // only when it was actually used in THIS window (the card is "last 30 days").
+    // All-time Cursor sessions don't count: claiming "Cursor too" when they haven't
+    // opened it in a month is just wrong.
     const CURSOR_MIN_SESSIONS = 3;
     const cursorStats = aiUsage["cursor"];
-    const cursorUntracked = !!(cursorStats && (cursorStats.total_sessions ?? 0) >= CURSOR_MIN_SESSIONS);
+    const cursorEstimated = !!(cursorStats && (cursorStats.total_sessions ?? 0) >= CURSOR_MIN_SESSIONS);
+    let cursorTokens = 0;
     for (const src of SOURCES) {
         const stats = aiUsage[src];
         if (!stats)
@@ -512,6 +514,8 @@ function computeTokens(aiUsage) {
             const cache = cacheTotal(b);
             workTokens += work;
             cacheTokens += cache;
+            if (src === "cursor")
+                cursorTokens += work + cache;
             // The per-tool bars + sparkline show the cache-inclusive total (matches the
             // rainbow headline); the "generated" callout is the work-only number.
             byTool[TOOL_LABELS[src] ?? src] =
@@ -570,7 +574,10 @@ function computeTokens(aiUsage) {
         by_tool: sortedByTool,
         six_month_buckets: sixMonth,
         estimated_retail_cost_usd: Math.round(totalCost),
-        cursor_untracked: cursorUntracked,
+        cursor_estimated: cursorEstimated,
+        cursor_token_share: cursorEstimated && workTokens + cacheTokens > 0
+            ? cursorTokens / (workTokens + cacheTokens)
+            : 0,
     };
 }
 function computeToolRelationship(aiUsage) {

package/dist/wrapped/render.js

@@ -453,9 +453,9 @@ function cardRankSummary(view) {
         .filter((stat) => stat.topNumber !== null)
         .sort((a, b) => a.topNumber - b.topNumber)[0];
     const cohort = rank.sample_size > 0
-        ? `across ${rank.sample_size.toLocaleString()} Standout users`
+        ? `across ${rank.sample_size.toLocaleString()} users`
         : view.cohort_size > 0
-            ? `among ${view.cohort_size.toLocaleString()} Standout users so far`
+            ? `among ${view.cohort_size.toLocaleString()} users so far`
             : "Standout profile summary";
     const row = (stat) => {
         const top = "top" in stat && stat.top
@@ -517,6 +517,14 @@ function cardTokens(view) {
     const costLine = cost > 0
         ? `   ${chalk.dim("would have cost")} ${TITLE_GRADIENT(`~$${cost.toLocaleString()}`)} ${chalk.dim("at retail API rates")}`
         : "";
+    // Cursor stores no token counts locally, so its tokens + cost are estimated
+    // from active time. Disclose it — wording scales with how much of this card is
+    // Cursor (cursor-only users: the whole number is an estimate).
+    const cursorNote = t.cursor_estimated
+        ? t.cursor_token_share >= 0.9
+            ? chalk.dim("   ≈ estimated from time spent in Cursor (no local token data)")
+            : chalk.dim("   includes Cursor (tokens + cost estimated from active time)")
+        : "";
     const cachedNote = t.cache_tokens > t.work_tokens
         ? chalk.dim("   thankfully, most of them were cached :)")
         : t.cache_tokens > 0
@@ -533,12 +541,10 @@ function cardTokens(view) {
         cachedNote,
         generatedLine,
         costLine,
+        cursorNote,
         "",
         "   last 30 days, across:",
         toolRows,
-        view.tokens.cursor_untracked
-            ? chalk.dim("   Cursor used too (its tokens aren't tracked locally)")
-            : "",
         "",
         deltaLine,
     ]
@@ -875,9 +881,9 @@ export function cardProficiency(view) {
     const scoreTop = topPercentNumber(p.score_percentile ?? null);
     const sampleSize = view.rank_summary.sample_size;
     const cohort = scoreTop != null && sampleSize > 0
-        ? `top ${scoreTop}% of ${sampleSize.toLocaleString()} Standout users`
+        ? `top ${scoreTop}% of ${sampleSize.toLocaleString()} users`
         : view.cohort_size > 0
-            ? `among ${view.cohort_size.toLocaleString()} Standout users so far`
+            ? `among ${view.cohort_size.toLocaleString()} users so far`
             : "";
     const metricRow = (label, value) => value === null
         ? null

package/dist/wrapped/types.d.ts

@@ -115,7 +115,8 @@ export interface WrappedAggregateView {
             tokens: number;
         }[];
         estimated_retail_cost_usd: number;
-        cursor_untracked: boolean;
+        cursor_estimated: boolean;
+        cursor_token_share: number;
     };
     tool_relationship: {
         kind: "switch";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.25",
+  "version": "0.5.26",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",