standout 0.5.24 → 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

@@ -469,6 +469,7 @@ export function aggregateView(args) {
             total_tokens_percentile: rankSummary.total_tokens_percentile ?? null,
             avg_agents_percentile: rankSummary.avg_agents_percentile ?? null,
             weekend_pct_percentile: rankSummary.weekend_pct_percentile ?? null,
+            ai_assisted_pct_percentile: rankSummary.ai_assisted_pct_percentile ?? null,
         },
         proficiency: parseProficiency(computedObj.proficiency),
         tokens,
@@ -494,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)
@@ -511,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] =
@@ -569,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/preview.js

@@ -76,6 +76,7 @@ function fixture(s) {
             total_tokens_percentile: s.intensity,
             avg_agents_percentile: s.intensity,
             weekend_pct_percentile: s.consistency,
+            ai_assisted_pct_percentile: s.intensity,
         },
         proficiency: {
             score: s.score,

package/dist/wrapped/render.js

@@ -200,12 +200,11 @@ function card1Open(view) {
             : perDay >= 1
                 ? "a daily habit at this point."
                 : "just getting warmed up.";
-    const badge = benchmarkBadge(view, view.rank_summary.hours_percentile, "of devs by session-hours");
+    const bench = benchmarkInline(view, view.rank_summary.hours_percentile);
     const lines = [
         chalk.dim("YOU MANAGED"),
         "",
-        bigNumber(`  ${hours}  session-hours`),
-        ...(badge ? ["", badge] : []),
+        bigNumber(`  ${hours}  session-hours`) + (bench ? ` ${bench}` : ""),
         "",
         chalk.white(`  ${verdict}`),
         chalk.dim("  across parallel agent sessions, last 30 days"),
@@ -261,7 +260,7 @@ function cardRhythm(view) {
         : "no clear peak";
     const weekendPct = Math.round(view.weekend_ratio * 100);
     const weekdayPct = 100 - weekendPct;
-    const weekendBadge = benchmarkBadge(view, view.rank_summary.weekend_pct_percentile, "of devs by weekend coding");
+    const weekendBench = benchmarkInline(view, view.rank_summary.weekend_pct_percentile);
     const isNightOwl = critter?.key === "night_owl";
     const subhead = isNightOwl
         ? "while the 9-5ers sleep, you ship."
@@ -281,7 +280,7 @@ function cardRhythm(view) {
         "",
         `  ${chalk.white("weekdays".padEnd(9))} ${bar(weekdayPct, 100, 20)} ${chalk.dim(weekdayPct + "%")}`,
         `  ${chalk.white("weekends".padEnd(9))} ${bar(weekendPct, 100, 20)} ${chalk.dim(weekendPct + "%")}`,
-        ...(weekendBadge ? ["", weekendBadge] : []),
+        ...(weekendBench ? ["", `  ${weekendBench}`] : []),
         "",
     ];
     if (view.rhythm_comment) {
@@ -350,13 +349,20 @@ function card7AINative(view) {
         : pct > 0
             ? "Claude's in your commit history. no going back."
             : "no AI-co-authored commits yet.";
+    const bench = benchmarkInline(view, view.rank_summary.ai_assisted_pct_percentile);
+    const streak = view.streak_days;
     const lines = [
         chalk.dim("YOU'RE AI-NATIVE"),
         "",
         `  commits since 2024:     ${chalk.white(view.total_commits.toLocaleString())}`,
         `  AI co-authored:         ${chalk.white(view.ai_assisted_commits.toLocaleString())}`,
         "",
-        `  ${bar(pct, 100, 26)}  ${chalk.white(pct + "%")}`,
+        `  ${bar(pct, 100, 22)}  ${chalk.white(pct + "%")}${bench ? ` ${bench}` : ""}`,
+        ...(streak >= 2
+            ? [
+                `  ${chalk.white(`${streak}-day streak`)}${chalk.dim(", coding without missing a day.")}`,
+            ]
+            : []),
         "",
         chalk.dim(subhead),
     ].join("\n");
@@ -399,16 +405,20 @@ function topPercent(percentile) {
     const top = topPercentNumber(percentile);
     return top === null ? null : `top ${top}%`;
 }
-// Inline "top X%" benchmark for a single metric card, gated on the same 100-user
-// cohort that unlocks the rest of the rankings. Returns null (line omitted) for
-// early adopters or until the metric has a percentile.
-function benchmarkBadge(view, percentile, dimension) {
+// Inline "(top X% of users)" cohort benchmark appended to a metric. Faint, except
+// when the user lands in the top <10% the percentile renders in the rainbow
+// gradient (the rest stays faint). Returns "" (omitted) for early adopters or
+// until the metric has a percentile, so callers can append conditionally.
+function benchmarkInline(view, percentile) {
     if (view.early_adopter)
-        return null;
+        return "";
     const top = topPercentNumber(percentile);
     if (top === null)
-        return null;
-    return `  ${chalk.hex("#ff8a00")(`top ${top}%`)} ${chalk.dim(dimension)}`;
+        return "";
+    const pct = `${top}%`;
+    return top < 10
+        ? chalk.dim("(top ") + TITLE_GRADIENT(pct) + chalk.dim(" of users)")
+        : chalk.dim(`(top ${pct} of users)`);
 }
 function cardRankSummary(view) {
     if (!usageReady(view) || view.total_sessions <= 0)
@@ -443,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
@@ -485,6 +495,7 @@ function cardTokens(view) {
     if (!usageReady(view) || (t.work_tokens <= 0 && t.cache_tokens <= 0))
         return "";
     const totalLine = bigNumber(formatTokens(t.total_30d) + " tokens");
+    const tokensBench = benchmarkInline(view, view.rank_summary.total_tokens_percentile);
     const max = Math.max(...t.by_tool.map((x) => x.tokens), 1);
     const toolRows = t.by_tool.length > 0
         ? t.by_tool
@@ -506,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
@@ -517,18 +536,15 @@ function cardTokens(view) {
     const lines = [
         chalk.dim("YOU BURNED THIS MANY TOKENS"),
         "",
-        `       ${totalLine}`,
-        benchmarkBadge(view, view.rank_summary.total_tokens_percentile, "of devs by tokens") ?? "",
+        `       ${totalLine}${tokensBench ? ` ${tokensBench}` : ""}`,
         "",
         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,
     ]
@@ -754,12 +770,11 @@ function cardConcurrency(view) {
     const longest = days >= 1.5
         ? `${days.toFixed(0)} days`
         : `${Math.round(c.longest_session_hours)}h`;
-    const badge = benchmarkBadge(view, view.rank_summary.avg_agents_percentile, "of devs by agents juggled");
+    const bench = benchmarkInline(view, view.rank_summary.avg_agents_percentile);
     const lines = [
         chalk.dim("HOW MANY AGENTS YOU JUGGLE"),
         "",
-        `  ${bigNumber(`~${c.open_tab_avg}`)} ${chalk.white("agents open at once")}`,
-        ...(badge ? ["", badge] : []),
+        `  ${bigNumber(`~${c.open_tab_avg}`)} ${chalk.white("agents open at once")}${bench ? ` ${bench}` : ""}`,
         "",
         `  ${chalk.white("peak".padEnd(14))} ${chalk.dim(`${c.open_tab_peak} at once`)}`,
         `  ${chalk.white("longest tab".padEnd(14))} ${chalk.dim(`${longest} open`)}`,
@@ -866,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

@@ -97,6 +97,7 @@ export interface WrappedAggregateView {
         total_tokens_percentile: number | null;
         avg_agents_percentile: number | null;
         weekend_pct_percentile: number | null;
+        ai_assisted_pct_percentile: number | null;
     };
     proficiency: ProficiencyView | null;
     tokens: {
@@ -114,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.24",
+  "version": "0.5.26",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",