standout 0.5.25 → 0.5.27

package/dist/cli.js

@@ -119,7 +119,7 @@ async function maybeShareWrapped(wrapped) {
         process.stderr.write(`  opened: ${wrapped.share_url}\n\n`);
     }
     catch (err) {
-        process.stderr.write(`  couldn't open browser — open it manually: ${wrapped.share_url}\n`);
+        process.stderr.write(`  couldn't open browser. open it manually: ${wrapped.share_url}\n`);
         process.stderr.write(`  (${err instanceof Error ? err.message : err})\n\n`);
     }
 }
@@ -197,7 +197,7 @@ async function runAgent(jobId) {
         await maybeShareWrapped(wrapped);
     }
     else {
-        process.stderr.write("  (couldn't generate wrapped right now — continuing profile setup.)\n\n");
+        process.stderr.write("  (couldn't generate wrapped right now. continuing profile setup.)\n\n");
     }
     if (!profileChatEnabled()) {
         return;

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/payload.js

@@ -104,6 +104,19 @@ export function capPayload(payload) {
             }
         }
     }
+    // 2b. Display-only prompt samples (not read by any server card).
+    if (over()) {
+        for (const t of TOOLS) {
+            const tool = asRecord(aiUsage[t]);
+            if (tool &&
+                Array.isArray(tool.prompt_samples) &&
+                tool.prompt_samples.length) {
+                tool.prompt_samples = [];
+                if (!dropped.includes("prompt_samples"))
+                    dropped.push("prompt_samples");
+            }
+        }
+    }
     // 3. Commit subjects + repo README excerpts (contributions/blurbs inputs).
     if (over()) {
         const aiCoding = asRecord(p.ai_coding);

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/dist/wrapped-client.js

@@ -10,18 +10,21 @@ const HEADERS = {
     // node-fetch UAs on certain paths. Set a clear identity.
     "User-Agent": "Standout/0.4.0 (node)",
 };
-// The request holds a connection open while the backend runs the wrapped's
-// LLM cards, so a transient blip shouldn't permanently drop the wrapped.
 const MAX_ATTEMPTS = 3;
-// Matches the server route's 300s maxDuration: the client only gives up once the
-// server itself would have. A shorter client timeout would abort a still-valid
-// slow run and orphan the wrapped the server goes on to create.
-const REQUEST_TIMEOUT_MS = 300000;
+// The POST now returns as soon as the pending row is created (the LLM card deck
+// runs server-side in the background), so it resolves in a couple seconds. The
+// deck is then read by polling GET /wrapped/[id] — short requests that can't be
+// silently dropped mid-generation the way the old long-held POST was.
+const POST_TIMEOUT_MS = 60000;
+const POLL_REQUEST_TIMEOUT_MS = 15000;
+const POLL_INTERVAL_MS = 2000;
+// Generous ceiling — the deck normally lands in well under a minute; this only
+// bounds a stuck/never-completing background pass.
+const POLL_TIMEOUT_MS = 180000;
 const RETRY_BASE_DELAY_MS = 1000;
-// Wrapped creation is NOT idempotent — each POST makes a new row + LLM run. Only
-// retry failures that prove the request never reached the backend; a timeout or a
-// mid-flight drop may mean the server already created it, so replaying would
-// duplicate the wrapped.
+// The POST is NOT idempotent — each one makes a new row + background LLM run. Only
+// retry failures that prove the request never reached the backend; a mid-flight
+// drop may mean the row was already created, so replaying would duplicate it.
 const RETRYABLE_CONNECT_CODES = new Set([
     "ECONNREFUSED",
     "ENOTFOUND",
@@ -37,46 +40,109 @@ function isPreConnectError(err) {
     }
     return false;
 }
+// `fetch failed` is undici's catch-all message — the real reason (ECONNRESET,
+// UND_ERR_HEADERS_TIMEOUT, …) lives in err.cause. Walk the chain so failures are
+// actually diagnosable instead of all collapsing to "fetch failed".
+function describeError(err) {
+    const parts = [];
+    let node = err;
+    for (let depth = 0; node && depth < 4; depth++) {
+        const e = node;
+        const code = typeof e.code === "string" ? e.code : null;
+        const message = typeof e.message === "string" ? e.message : null;
+        const label = [code, message].filter(Boolean).join(" ");
+        if (label && !parts.includes(label))
+            parts.push(label);
+        node = node?.cause;
+    }
+    return parts.join(" <- ") || String(err);
+}
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function isReady(computed) {
+    if (!computed)
+        return false;
+    // status is the explicit signal; archetype is a backstop for any response that
+    // predates the status field.
+    return computed.status === "ready" || computed.archetype != null;
+}
+// Poll GET /wrapped/[id] until the background card deck is persisted. Each request
+// is short and idempotent, so transient blips are retried freely (unlike the POST).
+async function pollComputed(id) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    // The deck never lands in under a second; wait once before the first read.
+    await sleep(POLL_INTERVAL_MS);
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${STANDOUT_API_URL}/api/public/wrapped/${id}`, {
+                headers: HEADERS,
+                signal: AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                if (isReady(data.computed))
+                    return data.computed ?? null;
+            }
+        }
+        catch {
+            // Transient — keep polling until the deadline.
+        }
+        await sleep(POLL_INTERVAL_MS);
+    }
+    return null;
+}
 export async function createWrapped(args) {
     // Keep the request under Vercel's 4.5MB body cap (else a heavy history 413s
     // before the handler runs). Trims the bulkiest raw fields only when oversized.
-    const { payload: profile } = capPayload(args.profile);
+    const { payload: profile, bytesAfter } = capPayload(args.profile);
     const body = JSON.stringify({
         profile,
         submission_id: args.submissionId ?? undefined,
     });
+    const bodyKb = Math.round(bytesAfter / 1024);
+    let created = null;
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
         try {
             const res = await fetch(`${STANDOUT_API_URL}/api/public/wrapped`, {
                 method: "POST",
                 headers: HEADERS,
                 body,
-                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                signal: AbortSignal.timeout(POST_TIMEOUT_MS),
             });
             // Any HTTP response means the request reached the server; don't replay it
             // (a 5xx could land after the row was already created).
             if (!res.ok) {
                 const text = await res.text().catch(() => "");
-                process.stderr.write(`[wrapped] backend returned ${res.status}${text ? `: ${text.slice(0, 200)}` : ""}\n`);
+                process.stderr.write(`  Standout had a server error (${res.status}) while building your wrapped. Please try again in a minute.\n` +
+                    (text ? `  (details: ${text.slice(0, 200)})\n` : ""));
                 return null;
             }
-            const data = (await res.json());
-            const view = aggregateView({
-                profile: args.profile,
-                computed: data.computed,
-                share_url: data.share_url,
-            });
-            return { id: data.id, share_url: data.share_url, view };
+            created = (await res.json());
+            break;
         }
         catch (err) {
             if (isPreConnectError(err) && attempt < MAX_ATTEMPTS) {
                 await sleep(RETRY_BASE_DELAY_MS * attempt);
                 continue;
             }
-            process.stderr.write(`[wrapped] failed to reach backend: ${err instanceof Error ? err.message : err}\n`);
+            process.stderr.write(`  Couldn't reach Standout to build your wrapped. Your network (or a VPN/proxy) dropped the connection.\n` +
+                `  Check your connection and re-run: npx standout\n` +
+                `  (details: ${describeError(err)}; body ${bodyKb}KB)\n`);
             return null;
         }
     }
-    return null;
+    if (!created)
+        return null;
+    // The POST only created a pending row; poll for the finished deck.
+    const computed = await pollComputed(created.id);
+    if (!computed) {
+        process.stderr.write("  Your wrapped is taking longer than usual to finish generating.\n" +
+            "  Re-run to try again: npx standout\n");
+        return null;
+    }
+    const view = aggregateView({
+        profile: args.profile,
+        computed,
+        share_url: created.share_url,
+    });
+    return { id: created.id, share_url: created.share_url, view };
 }

package/package.json

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