standout 0.1.0 → 0.5.15

package/dist/wrapped/aggregate.js

@@ -0,0 +1,792 @@
+const SOURCES = ["claude_code", "codex", "cursor"];
+const TOOL_LABELS = {
+    claude_code: "Claude Code",
+    codex: "Codex",
+    cursor: "Cursor",
+};
+const RETAIL_RATES = [
+    {
+        match: /claude.*opus/i,
+        input: 15,
+        output: 75,
+        cacheRead: 1.5,
+        cacheWrite: 18.75,
+    },
+    {
+        match: /claude.*sonnet/i,
+        input: 3,
+        output: 15,
+        cacheRead: 0.3,
+        cacheWrite: 3.75,
+    },
+    {
+        match: /claude.*haiku/i,
+        input: 1,
+        output: 5,
+        cacheRead: 0.1,
+        cacheWrite: 1.25,
+    },
+    {
+        match: /gpt-?5(-mini|-nano)?/i,
+        input: 1.25,
+        output: 10,
+        cacheRead: 0.125,
+        cacheWrite: 1.25,
+    },
+    {
+        match: /gpt-?4/i,
+        input: 2.5,
+        output: 10,
+        cacheRead: 0.25,
+        cacheWrite: 2.5,
+    },
+];
+function rateForModel(model) {
+    if (model) {
+        for (const r of RETAIL_RATES) {
+            if (r.match.test(model))
+                return {
+                    input: r.input,
+                    output: r.output,
+                    cacheRead: r.cacheRead,
+                    cacheWrite: r.cacheWrite,
+                };
+        }
+    }
+    return { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }; // generic fallback
+}
+function classifyProvider(model) {
+    const m = model.toLowerCase();
+    if (m.startsWith("claude") || m.includes("anthropic"))
+        return "anthropic";
+    if (m.startsWith("gpt") ||
+        m.includes("openai") ||
+        m.startsWith("o1") ||
+        m.startsWith("o3"))
+        return "openai";
+    return "other";
+}
+function asObject(v) {
+    return v && typeof v === "object" ? v : {};
+}
+function str(v) {
+    return typeof v === "string" ? v : "";
+}
+function strOrNull(v) {
+    return typeof v === "string" && v.length > 0 ? v : null;
+}
+// Defensive parse of computed.collaboration (background-generated; absent on the
+// first run). Returns null unless the core fields are present.
+function parseCollaboration(v) {
+    const o = asObject(v);
+    if (!o.style_label || !o.summary)
+        return null;
+    const signals = asObject(o.signals);
+    const funFacts = asObject(o.fun_facts);
+    return {
+        style_label: str(o.style_label),
+        summary: str(o.summary),
+        signals: {
+            fact_checking: str(signals.fact_checking),
+            depth: str(signals.depth),
+            autonomy: str(signals.autonomy),
+            complexity: str(signals.complexity),
+        },
+        fun_facts: {
+            most_common_ask: strOrNull(funFacts.most_common_ask),
+            weirdest_prompt: strOrNull(funFacts.weirdest_prompt),
+        },
+        generated_by: o.generated_by === "llm" ? "llm" : "heuristic",
+    };
+}
+function parseProficiency(v) {
+    const o = asObject(v);
+    if (typeof o.score !== "number")
+        return null;
+    const num = (x) => typeof x === "number" && Number.isFinite(x) ? x : null;
+    const dim = o.top_dimension === "intensity" ||
+        o.top_dimension === "consistency" ||
+        o.top_dimension === "craft"
+        ? o.top_dimension
+        : "intensity";
+    return {
+        score: o.score,
+        intensity: num(o.intensity),
+        consistency: num(o.consistency) ?? 0,
+        craft: num(o.craft),
+        base: num(o.base) ?? o.score,
+        craft_bonus: num(o.craft_bonus) ?? 0,
+        top_dimension: dim,
+        score_percentile: num(o.score_percentile),
+        comment: strOrNull(o.comment) ?? "",
+    };
+}
+function parseContributions(v) {
+    const o = asObject(v);
+    if (typeof o.one_liner !== "string" || o.one_liner.length === 0)
+        return null;
+    const themes = Array.isArray(o.themes)
+        ? o.themes.filter((t) => typeof t === "string")
+        : [];
+    return { one_liner: o.one_liner, themes };
+}
+function parseProjectBlurbs(v) {
+    const out = new Map();
+    if (!Array.isArray(v))
+        return out;
+    for (const item of v) {
+        const o = asObject(item);
+        if (typeof o.name === "string" && typeof o.blurb === "string" && o.blurb) {
+            out.set(o.name, o.blurb);
+        }
+    }
+    return out;
+}
+function asReadinessStatus(v, fallback) {
+    return v === "ready" ||
+        v === "scanning" ||
+        v === "enriching" ||
+        v === "unavailable" ||
+        v === "error"
+        ? v
+        : fallback;
+}
+function compactCwd(cwd) {
+    // Collapse parallel worktrees of one repo to a single project label. The CLI
+    // already canonicalizes these, but older/stored profiles may carry raw paths.
+    //   ~/work/standout/.worktrees/feat-x      → work/standout
+    //   ~/work/standout/.claude/worktrees/foo  → work/standout
+    const base = cwd
+        .replace(/\/\.claude\/worktrees\/[^/]+.*$/, "")
+        .replace(/\/\.worktrees\/[^/]+.*$/, "");
+    const segments = base.split("/").filter(Boolean);
+    // Conductor parallel workspaces ~/conductor/workspaces/<repo>/<leaf> → <repo>.
+    const ci = segments.indexOf("conductor");
+    if (ci >= 0 && segments[ci + 1] === "workspaces" && segments[ci + 2]) {
+        return segments[ci + 2];
+    }
+    return segments.slice(-2).join("/") || base;
+}
+export function aggregateView(args) {
+    const { profile, computed, share_url } = args;
+    const identity = asObject(profile.identity);
+    const aiUsage = asObject(profile.ai_usage);
+    const aiCoding = asObject(profile.ai_coding);
+    const explicitReadiness = asObject(profile.readiness);
+    let totalHours = 0;
+    let totalSessions = 0;
+    let activeDays = 0;
+    let streakDays = 0;
+    let weekendWeightedSum = 0;
+    let weekendWeightTotal = 0;
+    const toolCounts = {};
+    let hourBuckets = [];
+    let peakHour = null;
+    let conductorWorkspaces = 0;
+    const frameworkCounts = new Map();
+    const promptSamples = [];
+    const promptsSeen = new Set();
+    const askMap = new Map();
+    const projectMap = new Map();
+    let usageStatsSeen = false;
+    let allTimeHours = 0;
+    let allTimeSessions = 0;
+    let allTimeActiveDays = 0;
+    let allTimeFirstSession = null;
+    let allTimeLastSession = null;
+    const allTimeMonthly = new Map();
+    // Peak hour + longest streak are computed over the FULL history (all-time),
+    // not the rolling 30-day window — otherwise they wobble day to day.
+    const allTimeHourBuckets = new Array(24).fill(0);
+    let allTimeStreak = 0;
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        if (!stats)
+            continue;
+        usageStatsSeen = true;
+        const allTime = stats.all_time;
+        if (allTime) {
+            allTimeHours += allTime.total_duration_hours ?? 0;
+            allTimeSessions += allTime.total_sessions ?? 0;
+            allTimeActiveDays = Math.max(allTimeActiveDays, allTime.active_days ?? 0);
+            if (allTime.first_session &&
+                (!allTimeFirstSession || allTime.first_session < allTimeFirstSession)) {
+                allTimeFirstSession = allTime.first_session;
+            }
+            if (allTime.last_session &&
+                (!allTimeLastSession || allTime.last_session > allTimeLastSession)) {
+                allTimeLastSession = allTime.last_session;
+            }
+            for (const b of allTime.monthly_buckets ?? []) {
+                const month = allTimeMonthly.get(b.month) ?? {
+                    sessions: 0,
+                    duration_hours: 0,
+                };
+                month.sessions += b.sessions ?? 0;
+                month.duration_hours += b.duration_hours ?? 0;
+                allTimeMonthly.set(b.month, month);
+            }
+            if (allTime.hour_buckets && allTime.hour_buckets.length === 24) {
+                for (let i = 0; i < 24; i++)
+                    allTimeHourBuckets[i] += allTime.hour_buckets[i] ?? 0;
+            }
+            allTimeStreak = Math.max(allTimeStreak, allTime.longest_streak_days ?? 0);
+        }
+        totalHours += stats.total_duration_hours ?? 0;
+        totalSessions += stats.total_sessions ?? 0;
+        activeDays = Math.max(activeDays, stats.active_days ?? 0);
+        streakDays = Math.max(streakDays, stats.longest_streak_days ?? 0);
+        if (typeof stats.weekend_ratio === "number") {
+            const weight = stats.total_sessions ?? 0;
+            weekendWeightedSum += stats.weekend_ratio * weight;
+            weekendWeightTotal += weight;
+        }
+        for (const [name, count] of Object.entries(stats.tool_call_counts ?? {})) {
+            toolCounts[name] = (toolCounts[name] ?? 0) + count;
+        }
+        if (stats.hour_buckets && stats.hour_buckets.length === 24) {
+            if (hourBuckets.length === 0)
+                hourBuckets = stats.hour_buckets.slice();
+            else
+                hourBuckets = hourBuckets.map((v, i) => v + (stats.hour_buckets?.[i] ?? 0));
+        }
+        // Merge per-framework usage counts so the stack orders by what's used most;
+        // fall back to presence (count 1) for older profiles without counts.
+        if (stats.framework_counts) {
+            for (const [fw, n] of Object.entries(stats.framework_counts))
+                frameworkCounts.set(fw, (frameworkCounts.get(fw) ?? 0) + n);
+        }
+        else {
+            for (const fw of stats.frameworks ?? [])
+                frameworkCounts.set(fw, (frameworkCounts.get(fw) ?? 0) + 1);
+        }
+        for (const p of stats.prompt_samples ?? []) {
+            if (!p || p.length < 16)
+                continue;
+            const key = p
+                .toLowerCase()
+                .replace(/[\s\p{P}]+$/u, "")
+                .slice(0, 160);
+            if (promptsSeen.has(key))
+                continue;
+            promptsSeen.add(key);
+            if (promptSamples.length < 6)
+                promptSamples.push(p);
+        }
+        for (const ask of stats.prompt_frequency ?? []) {
+            if (!ask?.text)
+                continue;
+            const key = ask.text.toLowerCase().slice(0, 120);
+            const existing = askMap.get(key);
+            if (existing)
+                existing.count += ask.count;
+            else
+                askMap.set(key, { text: ask.text, count: ask.count });
+        }
+        for (const proj of stats.projects ?? []) {
+            if (proj.cwd?.includes("/conductor/")) {
+                conductorWorkspaces += proj.session_count;
+            }
+            const label = compactCwd(proj.cwd);
+            projectMap.set(label, (projectMap.get(label) ?? 0) + proj.session_count);
+        }
+    }
+    // "WHEN YOU CODE" + peak are computed over the full history when available
+    // (stable), falling back to the 30-day window only if all-time is missing.
+    const allTimeHasHours = allTimeHourBuckets.some((v) => v > 0);
+    let histogram = allTimeHasHours ? allTimeHourBuckets : hourBuckets;
+    if (histogram.length === 0)
+        histogram = new Array(24).fill(0);
+    // Peak hour = argmax of that merged histogram (consistent with the bars drawn).
+    let peakVal = 0;
+    histogram.forEach((count, hour) => {
+        if (count > peakVal) {
+            peakVal = count;
+            peakHour = hour;
+        }
+    });
+    // Longest streak over the full history (only grows over time), falling back to
+    // the 30-day streak if all-time isn't available.
+    if (allTimeStreak > 0)
+        streakDays = allTimeStreak;
+    const topTools = Object.entries(toolCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([name, count]) => ({ name, count }));
+    // Merge git repos you committed to (local.repos, all-time commits) with the
+    // AI-session cwds, so projects worked on outside Claude Code/Codex appear too.
+    const localRepos = Array.isArray(asObject(profile.local).repos)
+        ? asObject(profile.local).repos
+        : [];
+    const projByName = new Map();
+    for (const r of localRepos) {
+        const name = typeof r.name === "string" ? r.name : null;
+        if (!name)
+            continue;
+        const commits = typeof r.commit_count === "number" ? r.commit_count : 0;
+        const existing = projByName.get(name);
+        // Two local clones can share a repo name (e.g. a stray 1-commit checkout and
+        // the real one with hundreds). Keep the fuller clone's count so the stray
+        // can't overwrite and bury the real project.
+        if (existing) {
+            if (commits > existing.commits)
+                existing.commits = commits;
+        }
+        else {
+            projByName.set(name, { label: name, name, commits, sessions: 0 });
+        }
+    }
+    for (const [label, sessions] of projectMap) {
+        const name = label.split("/").filter(Boolean).pop() ?? label;
+        const existing = projByName.get(name);
+        if (existing) {
+            existing.sessions += sessions;
+            existing.label = label;
+        }
+        else {
+            projByName.set(name, { label, name, commits: 0, sessions });
+        }
+    }
+    const topProjects = [
+        ...projByName.values(),
+    ]
+        .sort((a, b) => b.commits - a.commits || b.sessions - a.sessions)
+        .slice(0, 12);
+    const totalCommits = aiCoding.total_commits_since_2024 ?? 0;
+    const aiAssistedCommits = aiCoding.ai_assisted_commits ?? 0;
+    const aiAssistedPct = totalCommits > 0 ? aiAssistedCommits / totalCommits : 0;
+    // ─────────────────────  tokens, tool relationship, models  ─────────────────────
+    const tokens = computeTokens(aiUsage);
+    const toolRelationship = computeToolRelationship(aiUsage);
+    const models = computeModels(aiUsage);
+    const computedObj = asObject(computed);
+    const archetypeLabel = typeof computedObj.archetype_label === "string"
+        ? computedObj.archetype_label
+        : "Builder";
+    const zinger = typeof computedObj.zinger === "string" && computedObj.zinger.length > 0
+        ? computedObj.zinger
+        : "just keeps building";
+    const mascotPose = (typeof computedObj.mascot_pose === "string"
+        ? computedObj.mascot_pose
+        : "default");
+    const earlyAdopter = computedObj.early_adopter !== false;
+    const cohortSize = computedObj.cohort_size ?? 0;
+    const percentileBands = asObject(computedObj.percentile_bands);
+    const rankSummary = asObject(computedObj.rank_summary);
+    const collaboration = parseCollaboration(computedObj.collaboration);
+    const contributions = parseContributions(computedObj.contributions);
+    const cardComments = asObject(computedObj.card_comments);
+    const talkThemes = Array.isArray(computedObj.talk_themes)
+        ? computedObj.talk_themes.filter((t) => typeof t === "string")
+        : [];
+    const projectBlurbs = parseProjectBlurbs(computedObj.project_blurbs);
+    if (projectBlurbs.size > 0) {
+        for (const p of topProjects) {
+            const repoName = p.label.split("/").filter(Boolean).pop() ?? p.label;
+            const blurb = projectBlurbs.get(repoName) ?? projectBlurbs.get(p.label);
+            if (blurb)
+                p.blurb = blurb;
+        }
+    }
+    const topAsks = [...askMap.values()]
+        .sort((a, b) => b.count - a.count)
+        .slice(0, 5);
+    const name = identity.name || identity.email || "you";
+    const readiness = {
+        usage_stats_status: asReadinessStatus(explicitReadiness.usage_stats_status, usageStatsSeen ? "ready" : "unavailable"),
+        profile_basics_status: asReadinessStatus(explicitReadiness.profile_basics_status, identity.name || identity.email || identity.github_username
+            ? "ready"
+            : "unavailable"),
+        enrichment_status: asReadinessStatus(explicitReadiness.enrichment_status, "unavailable"),
+    };
+    return {
+        readiness,
+        name,
+        archetype_label: archetypeLabel,
+        zinger,
+        mascot_pose: mascotPose,
+        total_hours: totalHours,
+        total_sessions: totalSessions,
+        active_days: activeDays,
+        streak_days: streakDays,
+        weekend_ratio: weekendWeightTotal > 0 ? weekendWeightedSum / weekendWeightTotal : 0,
+        top_tools: topTools,
+        hour_histogram: histogram,
+        peak_hour: peakHour,
+        conductor_workspaces: conductorWorkspaces,
+        top_projects: topProjects,
+        contributions,
+        all_time: {
+            total_hours: +allTimeHours.toFixed(1),
+            total_sessions: allTimeSessions,
+            active_days: allTimeActiveDays,
+            first_session: allTimeFirstSession,
+            last_session: allTimeLastSession,
+            monthly_buckets: [...allTimeMonthly.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([month, b]) => ({
+                month,
+                sessions: b.sessions,
+                duration_hours: +b.duration_hours.toFixed(1),
+            })),
+        },
+        frameworks: [...frameworkCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([fw]) => fw),
+        prompt_samples: promptSamples,
+        top_asks: topAsks,
+        collaboration,
+        total_commits: totalCommits,
+        ai_assisted_commits: aiAssistedCommits,
+        ai_assisted_pct: aiAssistedPct,
+        code_footprint: computeCodeFootprint(aiCoding, totalCommits, strOrNull(cardComments.footprint)),
+        concurrency: computeConcurrency(aiUsage, strOrNull(cardComments.concurrency)),
+        conversation: computeConversation(aiUsage, strOrNull(cardComments.talk), talkThemes),
+        rhythm_comment: strOrNull(cardComments.rhythm),
+        stack_comment: strOrNull(cardComments.stack),
+        early_adopter: earlyAdopter,
+        cohort_size: cohortSize,
+        percentile_bands: {
+            typescript_shippers: percentileBands.typescript_shippers ?? null,
+            ai_native: percentileBands.ai_native ?? null,
+            open_source: percentileBands.open_source ?? null,
+        },
+        rank_summary: {
+            sample_size: rankSummary.sample_size ?? 0,
+            hours_percentile: rankSummary.hours_percentile ?? null,
+            sessions_percentile: rankSummary.sessions_percentile ?? null,
+            active_days_percentile: rankSummary.active_days_percentile ?? null,
+            tokens_percentile: rankSummary.tokens_percentile ?? null,
+            commit_days_percentile: rankSummary.commit_days_percentile ?? null,
+        },
+        proficiency: parseProficiency(computedObj.proficiency),
+        tokens,
+        tool_relationship: toolRelationship,
+        models,
+        share_url,
+    };
+}
+// ─────────────────────  helpers  ─────────────────────
+function computeTokens(aiUsage) {
+    // The scanner feeds this view a rolling 30-day window. Sum all retained
+    // monthly buckets because a rolling window often spans two calendar months.
+    const displayMonths = new Map();
+    const byTool = {};
+    let totalCost = 0;
+    let workTokens = 0;
+    let cacheTokens = 0;
+    let workPrior30d = 0;
+    // Headline = "work" tokens the model actually generated/read fresh
+    // (input + output). Cache is reported separately because it's mostly the same
+    // context re-read every turn and would otherwise dwarf the number 100x.
+    const workTotal = (b) => (b.input_tokens ?? 0) + (b.output_tokens ?? 0);
+    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.
+    const CURSOR_MIN_SESSIONS = 3;
+    const cursorStats = aiUsage["cursor"];
+    const cursorUntracked = !!(cursorStats && (cursorStats.total_sessions ?? 0) >= CURSOR_MIN_SESSIONS);
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        if (!stats)
+            continue;
+        const buckets = stats.monthly_buckets ?? [];
+        for (const b of buckets) {
+            const work = workTotal(b);
+            const cache = cacheTotal(b);
+            workTokens += work;
+            cacheTokens += 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] =
+                (byTool[TOOL_LABELS[src] ?? src] ?? 0) + work + cache;
+            const rate = rateForModel(b.primary_model);
+            const cacheRead = b.cache_read_tokens ??
+                (b.cache_write_tokens === undefined ? (b.cache_tokens ?? 0) : 0);
+            const cacheWrite = b.cache_write_tokens ?? 0;
+            totalCost +=
+                ((b.input_tokens ?? 0) * rate.input) / 1_000_000 +
+                    ((b.output_tokens ?? 0) * rate.output) / 1_000_000 +
+                    (cacheRead * rate.cacheRead) / 1_000_000 +
+                    (cacheWrite * rate.cacheWrite) / 1_000_000;
+        }
+        const priorBuckets = stats.previous_30d?.monthly_buckets ?? [];
+        workPrior30d +=
+            priorBuckets.reduce((sum, b) => sum + workTotal(b), 0) ||
+                (stats.previous_30d?.total_input_tokens ?? 0) +
+                    (stats.previous_30d?.total_output_tokens ?? 0);
+        const monthSource = stats.all_time?.monthly_buckets && stats.all_time.monthly_buckets.length
+            ? stats.all_time.monthly_buckets
+            : buckets;
+        for (const b of monthSource) {
+            const m = displayMonths.get(b.month) ?? { tokens: 0 };
+            m.tokens += workTotal(b) + cacheTotal(b);
+            displayMonths.set(b.month, m);
+        }
+    }
+    const sortedMonths = [...displayMonths.keys()].sort();
+    const thisMonth = sortedMonths[sortedMonths.length - 1] ?? null;
+    // Omit tools with no token data (e.g. Cursor, which we can't read tokens for)
+    // so the card never renders a dead "Cursor ░░░░ 0" row.
+    const sortedByTool = Object.entries(byTool)
+        .filter(([, tokens]) => tokens > 0)
+        .sort(([, a], [, b]) => b - a)
+        .map(([tool, tokens]) => ({ tool, tokens }));
+    // 6-month sparkline
+    const sixMonth = [];
+    if (thisMonth) {
+        const [year, month] = thisMonth.split("-").map(Number);
+        for (let i = 5; i >= 0; i--) {
+            const d = new Date(Date.UTC(year, month - 1 - i, 1));
+            const key = d.toISOString().slice(0, 7);
+            sixMonth.push({
+                month: key,
+                tokens: displayMonths.get(key)?.tokens ?? 0,
+            });
+        }
+    }
+    return {
+        work_tokens: workTokens,
+        cache_tokens: cacheTokens,
+        total_30d: workTokens + cacheTokens,
+        total_prior_30d: workPrior30d,
+        multiplier_vs_prior: workTokens > 0 && workPrior30d > 0 ? workTokens / workPrior30d : null,
+        by_tool: sortedByTool,
+        six_month_buckets: sixMonth,
+        estimated_retail_cost_usd: Math.round(totalCost),
+        cursor_untracked: cursorUntracked,
+    };
+}
+function computeToolRelationship(aiUsage) {
+    // Build a per-month, per-tool session map across the trailing 6 months
+    const monthMap = new Map();
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        if (!stats)
+            continue;
+        for (const b of stats.monthly_buckets ?? []) {
+            let row = monthMap.get(b.month);
+            if (!row) {
+                row = new Map();
+                monthMap.set(b.month, row);
+            }
+            row.set(src, (row.get(src) ?? 0) + b.sessions);
+        }
+    }
+    const months = [...monthMap.keys()].sort();
+    if (months.length < 2) {
+        // Not enough data to detect a relationship — fall back to "loyalist" if there's
+        // any single-tool usage, otherwise insufficient.
+        if (months.length === 1) {
+            const row = monthMap.get(months[0]);
+            const best = [...row.entries()].sort(([, a], [, b]) => b - a)[0];
+            if (best) {
+                return {
+                    kind: "loyalist",
+                    tool: TOOL_LABELS[best[0]] ?? best[0],
+                    months_count: 1,
+                    sessions_count: best[1],
+                };
+            }
+        }
+        return { kind: "insufficient" };
+    }
+    const timeline = [];
+    for (const month of months) {
+        const row = monthMap.get(month);
+        const total = [...row.values()].reduce((a, b) => a + b, 0);
+        if (total === 0)
+            continue;
+        const sorted = [...row.entries()].sort(([, a], [, b]) => b - a);
+        const [topTool, topCount] = sorted[0];
+        timeline.push({
+            month,
+            dominant: topTool,
+            share: topCount / total,
+        });
+    }
+    // Detect a switch — find the longest run of consistent dominance, then look for
+    // a transition at the end. If the last 2+ months differ from the first 2+ months,
+    // that's a switch.
+    const dominants = timeline.map((t) => t.dominant);
+    const lastDominant = dominants[dominants.length - 1];
+    const firstDominant = dominants[0];
+    if (firstDominant && lastDominant && firstDominant !== lastDominant) {
+        // Find the month where the switch became permanent
+        let switchIdx = -1;
+        for (let i = dominants.length - 1; i >= 1; i--) {
+            if (dominants[i] === lastDominant && dominants[i - 1] !== lastDominant) {
+                switchIdx = i;
+                break;
+            }
+        }
+        if (switchIdx > 0) {
+            return {
+                kind: "switch",
+                from_tool: TOOL_LABELS[firstDominant] ?? firstDominant,
+                to_tool: TOOL_LABELS[lastDominant] ?? lastDominant,
+                switch_month: timeline[switchIdx].month,
+                timeline: timeline.map((t) => ({
+                    month: t.month,
+                    dominant: TOOL_LABELS[t.dominant] ?? t.dominant,
+                    share: t.share,
+                })),
+            };
+        }
+    }
+    // No switch detected — check if all months had the same dominant tool (loyalist)
+    // or if it's been a mix (polyglot)
+    const uniqueDominants = new Set(dominants);
+    if (uniqueDominants.size === 1) {
+        let totalSessions = 0;
+        for (const row of monthMap.values()) {
+            totalSessions += row.get(firstDominant) ?? 0;
+        }
+        return {
+            kind: "loyalist",
+            tool: TOOL_LABELS[firstDominant] ?? firstDominant,
+            months_count: months.length,
+            sessions_count: totalSessions,
+        };
+    }
+    // Polyglot — bouncing between tools across months
+    const totalsByTool = new Map();
+    for (const row of monthMap.values()) {
+        for (const [tool, n] of row) {
+            totalsByTool.set(tool, (totalsByTool.get(tool) ?? 0) + n);
+        }
+    }
+    const grandTotal = [...totalsByTool.values()].reduce((a, b) => a + b, 0);
+    const tools = [...totalsByTool.entries()]
+        .sort(([, a], [, b]) => b - a)
+        .map(([tool, n]) => ({
+        tool: TOOL_LABELS[tool] ?? tool,
+        share: grandTotal > 0 ? n / grandTotal : 0,
+    }));
+    return { kind: "polyglot", tools };
+}
+function computeModels(aiUsage) {
+    const allModelCounts = new Map();
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        if (!stats?.model_session_counts)
+            continue;
+        for (const [model, n] of Object.entries(stats.model_session_counts)) {
+            allModelCounts.set(model, (allModelCounts.get(model) ?? 0) + n);
+        }
+    }
+    const totalClassified = [...allModelCounts.values()].reduce((a, b) => a + b, 0);
+    if (totalClassified === 0) {
+        return { by_provider: [], top_model: null };
+    }
+    const byProvider = new Map();
+    for (const [model, sessions] of allModelCounts) {
+        const provider = classifyProvider(model);
+        const entry = byProvider.get(provider) ?? { sessions: 0, models: [] };
+        entry.sessions += sessions;
+        entry.models.push({ name: model, sessions });
+        byProvider.set(provider, entry);
+    }
+    const providers = [
+        ...byProvider.entries(),
+    ]
+        .sort(([, a], [, b]) => b.sessions - a.sessions)
+        .map(([provider, entry]) => ({
+        provider,
+        sessions: entry.sessions,
+        share: entry.sessions / totalClassified,
+        models: entry.models.sort((a, b) => b.sessions - a.sessions).slice(0, 4),
+    }));
+    let topModel = null;
+    let topCount = 0;
+    for (const [name, sessions] of allModelCounts) {
+        if (sessions > topCount) {
+            topCount = sessions;
+            topModel = {
+                name,
+                sessions,
+                share: sessions / totalClassified,
+            };
+        }
+    }
+    return { by_provider: providers, top_model: topModel };
+}
+function footprintLabel(net, additiveRatio) {
+    if (net <= 0)
+        return "Cleaner";
+    if (additiveRatio >= 0.7)
+        return "Shipper";
+    return "Refactorer";
+}
+function computeCodeFootprint(aiCoding, totalCommits, line) {
+    const added = aiCoding.lines_added_since_2024 ?? 0;
+    const deleted = aiCoding.lines_deleted_since_2024 ?? 0;
+    if (added === 0 && deleted === 0)
+        return null;
+    const net = added - deleted;
+    const additiveRatio = added + deleted > 0 ? added / (added + deleted) : 0;
+    return {
+        lines_added: added,
+        lines_deleted: deleted,
+        net,
+        additive_ratio: +additiveRatio.toFixed(2),
+        median_commit_size: aiCoding.median_commit_size ?? 0,
+        biggest_commit_size: aiCoding.biggest_commit_size ?? 0,
+        lines_per_commit: totalCommits > 0 ? Math.round((added + deleted) / totalCommits) : 0,
+        label: footprintLabel(net, additiveRatio),
+        line,
+    };
+}
+// Concurrency comes from the tool with the most sessions (the user's main
+// driver) — open-tab overlap isn't additive across tools.
+function computeConcurrency(aiUsage, line) {
+    let best = null;
+    let bestSessions = -1;
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        if (!stats?.concurrency)
+            continue;
+        const sessions = stats.total_sessions ?? 0;
+        if (sessions > bestSessions) {
+            bestSessions = sessions;
+            best = stats.concurrency;
+        }
+    }
+    if (!best)
+        return null;
+    return {
+        open_tab_avg: best.open_tab_avg ?? 0,
+        open_tab_peak: best.open_tab_peak ?? 0,
+        longest_session_hours: best.longest_session_hours ?? 0,
+        active_juggle_pct: best.active_juggle_pct ?? 0,
+        line,
+    };
+}
+function computeConversation(aiUsage, line, themes) {
+    let totalPrompts = 0;
+    let questionWeighted = 0;
+    let charsWeighted = 0;
+    for (const src of SOURCES) {
+        const stats = aiUsage[src];
+        const c = stats?.conversation;
+        if (!c)
+            continue;
+        const n = c.total_prompts ?? 0;
+        totalPrompts += n;
+        questionWeighted += (c.question_ratio ?? 0) * n;
+        charsWeighted += (c.avg_prompt_chars ?? 0) * n;
+    }
+    if (totalPrompts === 0)
+        return null;
+    return {
+        total_prompts: totalPrompts,
+        question_ratio: +(questionWeighted / totalPrompts).toFixed(2),
+        avg_prompt_chars: Math.round(charsWeighted / totalPrompts),
+        line,
+        themes,
+    };
+}