standout 0.1.0 → 0.5.15

package/dist/wrapped/render.js

@@ -0,0 +1,996 @@
+import boxen from "boxen";
+import chalk from "chalk";
+import gradient from "gradient-string";
+import { createInterface } from "readline";
+import { chronoCritterForHour } from "./chrono-critters.js";
+import { MASCOTS } from "./mascots.js";
+import { tierForScore } from "./tiers.js";
+const BOX_WIDTH = 56;
+const SPARK_BARS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+const TITLE_GRADIENT = gradient(["#ff8a00", "#ff4d6d", "#ad5cff"]);
+// ───────────────── input helpers ─────────────────
+async function waitForKey() {
+    if (!process.stdin.isTTY) {
+        // No keypresses to wait for when captured (e.g. inside Claude Code); advance
+        // immediately so the full wrapped prints without seconds of dead time.
+        return "\r";
+    }
+    return new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const handler = (data) => {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stdin.removeListener("data", handler);
+            const key = data.toString();
+            // Ctrl-C → exit cleanly
+            if (key === "\u0003") {
+                process.stdout.write("\n");
+                process.exit(0);
+            }
+            resolve(key);
+        };
+        process.stdin.on("data", handler);
+    });
+}
+async function askLine(prompt) {
+    if (!process.stdin.isTTY)
+        return "y";
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stderr,
+        });
+        rl.question(prompt, (ans) => {
+            rl.close();
+            resolve(ans.trim());
+        });
+    });
+}
+// ───────────────── rendering helpers ─────────────────
+function box(content, opts = {}) {
+    return boxen(content, {
+        padding: { top: 1, bottom: 1, left: 2, right: 2 },
+        margin: { top: 0, bottom: 0, left: 2, right: 2 },
+        width: BOX_WIDTH,
+        borderStyle: "round",
+        borderColor: opts.borderColor ?? "gray",
+    });
+}
+function usageReady(view) {
+    return view.readiness.usage_stats_status === "ready";
+}
+function hasHistogramData(view) {
+    return view.hour_histogram.some((v) => v > 0);
+}
+function divider(label) {
+    return chalk.dim(`\n  ${label.padEnd(48, " ")}  ${chalk.dim("[press ↵]")}\n`);
+}
+function wrapWords(text, width) {
+    const words = text.split(/\s+/).filter(Boolean);
+    const lines = [];
+    let line = "";
+    for (const w of words) {
+        if (line && line.length + w.length + 1 > width) {
+            lines.push(line);
+            line = w;
+        }
+        else {
+            line = line ? `${line} ${w}` : w;
+        }
+    }
+    if (line)
+        lines.push(line);
+    return lines;
+}
+function bigNumber(s) {
+    return TITLE_GRADIENT(s);
+}
+// Inner content width of a box() — BOX_WIDTH minus borders (2) and h-padding (4).
+const INNER_WIDTH = BOX_WIDTH - 6;
+function leftPad(visibleLen) {
+    return " ".repeat(Math.max(0, Math.floor((INNER_WIDTH - visibleLen) / 2)));
+}
+function centerText(raw, color) {
+    const pad = leftPad(raw.length);
+    return pad + (color ? color(raw) : raw);
+}
+// Center a multi-line ASCII figure as a block — one shared left margin keeps the
+// art's internal alignment intact.
+function centerBlock(art, color) {
+    const lines = art.split("\n");
+    const width = Math.max(...lines.map((l) => l.length));
+    const pad = leftPad(width);
+    return lines.map((l) => pad + (color ? color(l) : l)).join("\n");
+}
+function bar(value, max, width) {
+    if (max === 0)
+        return " ".repeat(width);
+    const filled = Math.round((value / max) * width);
+    return (chalk.hex("#ff8a00")("█".repeat(filled)) +
+        chalk.gray("░".repeat(width - filled)));
+}
+// Compact line/number formatting: 230482 → "230.5k", 3200 → "3.2k".
+function compactNum(n) {
+    const sign = n < 0 ? "-" : "";
+    const abs = Math.abs(n);
+    if (abs >= 1000)
+        return `${sign}${(abs / 1000).toFixed(abs >= 100000 ? 0 : 1)}k`;
+    return `${sign}${abs}`;
+}
+function coloredBar(value, max, width, hex) {
+    if (max <= 0)
+        return chalk.gray("░".repeat(width));
+    const filled = Math.max(0, Math.min(width, Math.round((value / max) * width)));
+    return (chalk.hex(hex)("█".repeat(filled)) + chalk.gray("░".repeat(width - filled)));
+}
+function sparkline(buckets) {
+    if (!buckets.length)
+        return "";
+    const max = Math.max(...buckets, 1);
+    return buckets
+        .map((v) => SPARK_BARS[Math.min(SPARK_BARS.length - 1, Math.floor((v / max) * (SPARK_BARS.length - 1)))])
+        .join("");
+}
+function hourlyChart(buckets, critter = null) {
+    const spark = sparkline(buckets);
+    const width = 24;
+    const axis = new Array(width).fill(" ");
+    for (const label of [
+        { at: 0, text: "00" },
+        { at: 6, text: "06" },
+        { at: 12, text: "12" },
+        { at: 18, text: "18" },
+        { at: 22, text: "23" },
+    ]) {
+        for (let i = 0; i < label.text.length; i++) {
+            axis[label.at + i] = label.text[i];
+        }
+    }
+    const left = [
+        chalk.hex("#ad5cff")(spark.padEnd(width, " ")),
+        chalk.dim(axis.join("")),
+    ];
+    if (!critter)
+        return left.map((l) => `  ${l}`);
+    const critterLines = critter.art.split("\n");
+    const blank = " ".repeat(width);
+    const rows = Math.max(left.length, critterLines.length);
+    // Bottom-align the chart within the (taller) critter so the graph + axis sit
+    // low, right above the caption, instead of floating at the top with a gap.
+    const topPad = rows - left.length;
+    return Array.from({ length: rows }, (_unused, i) => {
+        const leftIdx = i - topPad;
+        const leftStr = leftIdx >= 0 ? (left[leftIdx] ?? blank) : blank;
+        const right = critterLines[i] ? "   " + critter.color(critterLines[i]) : "";
+        return `  ${leftStr}${right}`;
+    });
+}
+function monthShort(month) {
+    const monthIndex = Number(month.slice(5, 7)) - 1;
+    return ([
+        "Jan",
+        "Feb",
+        "Mar",
+        "Apr",
+        "May",
+        "Jun",
+        "Jul",
+        "Aug",
+        "Sep",
+        "Oct",
+        "Nov",
+        "Dec",
+    ][monthIndex] ?? month);
+}
+function monthYearShort(month) {
+    const year = month.slice(2, 4);
+    return `${monthShort(month)} ${year}`;
+}
+// ───────────────── card builders ─────────────────
+function card1Open(view) {
+    if (!usageReady(view) || view.total_sessions <= 0)
+        return "";
+    const hours = Math.round(view.total_hours).toLocaleString();
+    const perDay = view.total_hours / 30;
+    const verdict = perDay >= 6
+        ? "that's a second full-time job. 996 who?"
+        : perDay >= 3
+            ? "basically a part-time gig with the machines."
+            : perDay >= 1
+                ? "a daily habit at this point."
+                : "just getting warmed up.";
+    const lines = [
+        chalk.dim("YOU MANAGED"),
+        "",
+        bigNumber(`  ${hours}  session-hours`),
+        "",
+        chalk.white(`  ${verdict}`),
+        chalk.dim("  across parallel agent sessions, last 30 days"),
+    ].join("\n");
+    return box(lines, { borderColor: "yellow" });
+}
+function cardAllTime(view) {
+    if (!usageReady(view) || view.all_time.total_sessions <= 0)
+        return "";
+    const months = view.all_time.monthly_buckets.slice(-12);
+    const max = Math.max(...months.map((m) => m.duration_hours), 1);
+    const rows = months.map((m) => {
+        const label = monthYearShort(m.month).padEnd(6);
+        return `  ${chalk.dim(label)}  ${bar(m.duration_hours, max, 20)} ${chalk.dim(`${Math.round(m.duration_hours)}h`)}`;
+    });
+    const since = view.all_time.first_session
+        ? new Date(view.all_time.first_session).toISOString().slice(0, 7)
+        : "your first local log";
+    const latest = months[months.length - 1];
+    const prior = months[months.length - 2];
+    const best = [...months].sort((a, b) => b.duration_hours - a.duration_hours)[0];
+    const trend = latest && prior && prior.duration_hours > 0
+        ? `${monthShort(latest.month)}: ${latest.duration_hours >= prior.duration_hours ? "+" : ""}${Math.round(((latest.duration_hours - prior.duration_hours) / prior.duration_hours) * 100)}% vs previous month`
+        : latest && prior && latest.duration_hours > 0
+            ? `${monthShort(latest.month)}: active after a quiet month`
+            : null;
+    const lines = [
+        chalk.dim("YOUR AI CODING YEAR"),
+        "",
+        `  ${bigNumber(`~${Math.round(view.all_time.total_hours).toLocaleString()} hours`)} from local logs`,
+        `  ${chalk.white(view.all_time.total_sessions.toLocaleString())} sessions detected since ${since}`,
+        ...(trend ? [`  ${chalk.dim(trend)}`] : []),
+        "",
+        ...rows,
+        best
+            ? `  ${chalk.dim(`best local-log month: ${monthShort(best.month)} · ~${Math.round(best.duration_hours)}h`)}`
+            : "",
+    ].join("\n");
+    return box(lines, { borderColor: "cyan" });
+}
+// WHEN YOU CODE: time-of-day rhythm + the weekday/weekend split. The peak hour
+// resolves to a chrono-critter (morning bird / daytimer / night owl) drawn to
+// the right of the graph in the card's border color, with a caption below. The
+// LLM rhythm line is preferred; the deterministic subhead is the fallback.
+function cardRhythm(view) {
+    if (!usageReady(view) || !hasHistogramData(view))
+        return "";
+    const borderColor = "magenta";
+    const peak = view.peak_hour;
+    const critter = peak !== null ? chronoCritterForHour(peak) : null;
+    const caption = critter
+        ? `${critter.label}: peak contributions at ${peak}:00`
+        : "no clear peak";
+    const weekendPct = Math.round(view.weekend_ratio * 100);
+    const weekdayPct = 100 - weekendPct;
+    const isNightOwl = critter?.key === "night_owl";
+    const subhead = isNightOwl
+        ? "while the 9-5ers sleep, you ship."
+        : weekendPct < 10
+            ? "locked in on weekdays, weekends are yours."
+            : weekendPct >= 35
+                ? "weekends are just more reps for you."
+                : peak !== null && peak < 9
+                    ? "up before standup. menace."
+                    : "you keep your own hours.";
+    const lines = [
+        chalk.dim("WHEN YOU CODE"),
+        "",
+        ...hourlyChart(view.hour_histogram, critter ? { art: critter.art, color: chalk.magenta } : null),
+        "",
+        `  ${chalk.white(caption)}`,
+        "",
+        `  ${chalk.white("weekdays".padEnd(9))} ${bar(weekdayPct, 100, 20)} ${chalk.dim(weekdayPct + "%")}`,
+        `  ${chalk.white("weekends".padEnd(9))} ${bar(weekendPct, 100, 20)} ${chalk.dim(weekendPct + "%")}`,
+        "",
+    ];
+    if (view.rhythm_comment) {
+        for (const l of wrapWords(view.rhythm_comment, 47))
+            lines.push(chalk.italic.white("  " + l));
+    }
+    else {
+        lines.push(chalk.dim("  " + subhead));
+    }
+    return box(lines.join("\n"), { borderColor });
+}
+// Capitalize each word of a repo slug: "idss-backend" → "Idss-Backend".
+function titleCaseName(name) {
+    return name
+        .split(/([-_ ])/)
+        .map((part) => /[-_ ]/.test(part) ? part : part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+}
+// Top 3 projects across AI sessions AND git repos you committed to. The #1
+// project is the hero (name + commits in gradient, description in white); the
+// rest are white titles with faint one-liners. Leads with the shipped summary.
+function cardProjects(view) {
+    if (!usageReady(view))
+        return "";
+    const projects = view.top_projects
+        .filter((p) => p.commits > 0 || p.sessions > 0)
+        .slice(0, 3);
+    if (projects.length === 0)
+        return "";
+    const lines = [chalk.dim("YOUR TOP PROJECTS"), ""];
+    const c = view.contributions;
+    if (c && c.one_liner) {
+        for (const l of wrapWords(c.one_liner, 50))
+            lines.push(chalk.dim(l));
+        lines.push("");
+    }
+    projects.forEach((p, i) => {
+        const count = p.commits > 0
+            ? `${p.commits.toLocaleString()} commit${p.commits === 1 ? "" : "s"}`
+            : `${p.sessions} session${p.sessions === 1 ? "" : "s"}`;
+        const name = titleCaseName(p.name);
+        if (i === 0) {
+            lines.push(`  ${bigNumber(`▸ ${name}`)}  ${TITLE_GRADIENT(count)}`);
+            if (p.blurb)
+                for (const l of wrapWords(p.blurb, 44))
+                    lines.push(`     ${chalk.white(l)}`);
+        }
+        else {
+            const namePart = `▸ ${name}`;
+            const pad = " ".repeat(Math.max(2, 24 - namePart.length));
+            lines.push(`  ${chalk.white(namePart)}${pad}${chalk.dim(count)}`);
+            if (p.blurb)
+                for (const l of wrapWords(p.blurb, 44))
+                    lines.push(`     ${chalk.dim(l)}`);
+        }
+        lines.push("");
+    });
+    return box(lines.join("\n").replace(/\n+$/, ""), { borderColor: "green" });
+}
+function card7AINative(view) {
+    if (view.total_commits <= 0)
+        return "";
+    const pct = Math.round(view.ai_assisted_pct * 100);
+    const subhead = pct >= 50
+        ? "cyborg arc: most commits ship with Claude now."
+        : pct > 0
+            ? "Claude's in your commit history. no going back."
+            : "no AI-co-authored commits yet.";
+    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 + "%")}`,
+        "",
+        chalk.dim(subhead),
+    ].join("\n");
+    return box(lines, { borderColor: "yellow" });
+}
+function card8Standing(view) {
+    if (view.early_adopter || !view.percentile_bands) {
+        const lines = [
+            chalk.dim("YOUR STANDING"),
+            "",
+            `  ${bigNumber("EARLY  ADOPTER")}`,
+            "",
+            chalk.dim(`you're 1 of ${view.cohort_size} devs in the network so far.`),
+            chalk.dim("percentile rankings unlock at 100 wrapped profiles."),
+        ].join("\n");
+        return box(lines, { borderColor: "magenta" });
+    }
+    const bands = view.percentile_bands;
+    const row = (label, percentile) => {
+        if (percentile === null)
+            return null;
+        const top = 100 - percentile;
+        const w = Math.max(2, Math.round((top / 100) * 28));
+        return `  ${chalk.hex("#ff8a00")("█".repeat(w))} ${chalk.dim("TOP " + top + "%")}\n  ${chalk.dim(label)}`;
+    };
+    const rows = [
+        row("TypeScript shippers", bands.typescript_shippers),
+        row("AI-native engineers", bands.ai_native),
+        row("Open-source contributors", bands.open_source),
+    ].filter(Boolean);
+    const lines = [chalk.dim("YOUR STANDING"), "", ...rows].join("\n\n");
+    return box(lines, { borderColor: "magenta" });
+}
+function topPercentNumber(percentile) {
+    if (percentile === null)
+        return null;
+    return Math.max(1, 100 - percentile);
+}
+function topPercent(percentile) {
+    const top = topPercentNumber(percentile);
+    return top === null ? null : `top ${top}%`;
+}
+function cardRankSummary(view) {
+    if (!usageReady(view) || view.total_sessions <= 0)
+        return "";
+    const rank = view.rank_summary;
+    const stats = [
+        {
+            label: "session-hrs",
+            value: `~${Math.round(view.total_hours)}h`,
+            bestText: `~${Math.round(view.total_hours)}h of session time`,
+            percentile: rank.hours_percentile,
+        },
+        {
+            label: "sessions",
+            value: view.total_sessions.toLocaleString(),
+            bestText: `${view.total_sessions.toLocaleString()} sessions`,
+            percentile: rank.sessions_percentile,
+        },
+        {
+            label: "active days",
+            value: view.active_days.toLocaleString(),
+            bestText: `${view.active_days.toLocaleString()} active days`,
+            percentile: rank.active_days_percentile,
+        },
+    ];
+    const ranked = stats.map((stat) => ({
+        ...stat,
+        top: topPercent(stat.percentile),
+        topNumber: topPercentNumber(stat.percentile),
+    }));
+    const best = ranked
+        .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`
+        : view.cohort_size > 0
+            ? `among ${view.cohort_size.toLocaleString()} Standout users so far`
+            : "Standout profile summary";
+    const row = (stat) => {
+        const top = "top" in stat && stat.top
+            ? chalk.hex("#ff8a00")(stat.top)
+            : chalk.dim("warming up");
+        return `  ${chalk.white(stat.label.padEnd(12))} ${chalk.dim(stat.value.padStart(10))}  ${top}`;
+    };
+    const lines = [
+        chalk.dim("WHERE YOU STAND"),
+        "",
+        best
+            ? `  ${bigNumber(`YOU ARE TOP ${best.topNumber}%`)}`
+            : `  ${bigNumber("EARLY")}`,
+        `  ${chalk.dim(cohort)}`,
+        "",
+        best
+            ? `  best stat: ${chalk.white(best.bestText)} last 30 days`
+            : `  best stats are still warming up`,
+        "",
+        ...ranked.map(row),
+        "",
+        `  ${chalk.dim(`~${Math.round(view.all_time.total_hours).toLocaleString()}h from local logs · ${view.all_time.total_sessions.toLocaleString()} sessions`)}`,
+    ].join("\n");
+    return box(lines, { borderColor: "magenta" });
+}
+function formatTokens(n) {
+    if (n >= 1_000_000_000)
+        return (n / 1_000_000_000).toFixed(1) + "B";
+    if (n >= 1_000_000)
+        return (n / 1_000_000).toFixed(1) + "M";
+    if (n >= 1_000)
+        return (n / 1_000).toFixed(1) + "K";
+    return n.toLocaleString();
+}
+function cardTokens(view) {
+    const t = view.tokens;
+    if (!usageReady(view) || (t.work_tokens <= 0 && t.cache_tokens <= 0))
+        return "";
+    const totalLine = bigNumber(formatTokens(t.total_30d) + " tokens");
+    const max = Math.max(...t.by_tool.map((x) => x.tokens), 1);
+    const toolRows = t.by_tool.length > 0
+        ? t.by_tool
+            .slice(0, 3)
+            .map((x) => {
+            const padTool = x.tool.padEnd(13, " ");
+            return `   ${chalk.white(padTool)} ${bar(x.tokens, max, 16)}  ${chalk.dim(formatTokens(x.tokens))}`;
+        })
+            .join("\n")
+        : chalk.dim("   (no tool breakdown available)");
+    const deltaLine = t.multiplier_vs_prior !== null && t.multiplier_vs_prior >= 1.05
+        ? chalk.hex("#ff8a00")(`   ↑ ${t.multiplier_vs_prior.toFixed(1)}× vs last period`)
+        : t.multiplier_vs_prior !== null && t.multiplier_vs_prior < 0.95
+            ? chalk.dim(`   ↓ ${(1 / t.multiplier_vs_prior).toFixed(1)}× less than last period`)
+            : t.total_prior_30d > 0
+                ? chalk.dim(`   ≈ same as last period`)
+                : chalk.dim(`   rolling 30-day window`);
+    const cost = t.estimated_retail_cost_usd;
+    const costLine = cost > 0
+        ? `   ${chalk.dim("would have cost")} ${TITLE_GRADIENT(`~$${cost.toLocaleString()}`)} ${chalk.dim("at retail API rates")}`
+        : "";
+    const cachedNote = t.cache_tokens > t.work_tokens
+        ? chalk.dim("   thankfully, most of them were cached :)")
+        : t.cache_tokens > 0
+            ? chalk.dim("   (includes cached context, re-read each turn)")
+            : "";
+    const generatedLine = t.work_tokens > 0
+        ? `   ${chalk.white(formatTokens(t.work_tokens))} ${chalk.dim("were actually generated fresh")}`
+        : "";
+    const lines = [
+        chalk.dim("YOU BURNED THIS MANY TOKENS"),
+        "",
+        `       ${totalLine}`,
+        "",
+        cachedNote,
+        generatedLine,
+        costLine,
+        "",
+        "   last 30 days, across:",
+        toolRows,
+        view.tokens.cursor_untracked
+            ? chalk.dim("   Cursor used too (its tokens aren't tracked locally)")
+            : "",
+        "",
+        deltaLine,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    return box(lines, { borderColor: "yellow" });
+}
+function cardToolRelationship(view) {
+    if (!usageReady(view))
+        return "";
+    const r = view.tool_relationship;
+    if (r.kind === "insufficient") {
+        return ""; // empty card — won't render
+    }
+    // Longest consecutive-day streak — a commitment stat that rides along with the
+    // tool-loyalty story (verbatim from the old standalone streak card).
+    const streakLine = view.streak_days >= 2
+        ? `   ${chalk.white(`${view.streak_days}-day streak, coding without missing a day.`)}`
+        : null;
+    if (r.kind === "switch") {
+        const rows = r.timeline.slice(-6).map((t) => {
+            const monthShort = t.month.slice(2).replace("-", "/");
+            const filled = Math.round(t.share * 10);
+            const bar = chalk.hex("#ff8a00")("█".repeat(filled)) +
+                chalk.gray("░".repeat(10 - filled));
+            const label = t.dominant === r.from_tool
+                ? chalk.dim(t.dominant)
+                : chalk.white(t.dominant);
+            return `  ${chalk.dim(monthShort)}  ${bar}  ${label}`;
+        });
+        return box([
+            chalk.dim("YOU SWITCHED TOOLS"),
+            "",
+            ...rows,
+            "",
+            chalk.dim(`   joined the "${r.from_tool} → ${r.to_tool}" club`),
+            chalk.dim(`   in ${r.switch_month}.`),
+            ...(streakLine ? ["", streakLine] : []),
+        ].join("\n"), { borderColor: "cyan" });
+    }
+    if (r.kind === "loyalist") {
+        return box([
+            chalk.dim("YOU'RE A LOYALIST"),
+            "",
+            `   ${bigNumber(r.tool.toUpperCase())}`,
+            "",
+            chalk.dim(`   ${r.sessions_count} sessions across ${r.months_count} month${r.months_count === 1 ? "" : "s"}.`),
+            chalk.dim("   no second-guessing. you knew what you wanted."),
+            ...(streakLine ? ["", streakLine] : []),
+        ].join("\n"), { borderColor: "cyan" });
+    }
+    if (r.kind === "polyglot") {
+        const rows = r.tools.slice(0, 4).map((t) => {
+            const filled = Math.round(t.share * 22);
+            const bar = chalk.hex("#ff8a00")("█".repeat(filled)) +
+                chalk.gray("░".repeat(22 - filled));
+            return `   ${chalk.white(t.tool.padEnd(12, " "))} ${bar}  ${chalk.dim(Math.round(t.share * 100) + "%")}`;
+        });
+        return box([
+            chalk.dim("YOU'RE A POLYGLOT"),
+            "",
+            ...rows,
+            "",
+            chalk.dim("   you don't pick favorites. respect."),
+            ...(streakLine ? ["", streakLine] : []),
+        ].join("\n"), { borderColor: "cyan" });
+    }
+    return "";
+}
+function shortenModelName(name) {
+    const n = name.toLowerCase();
+    const ver = (s) => s.replace(/-/g, ".");
+    let mm;
+    if ((mm = n.match(/^claude-(opus|sonnet|haiku)-(\d+(?:-\d+)*)/)))
+        return `${mm[1][0].toUpperCase()}${mm[1].slice(1)} ${ver(mm[2])}`;
+    if ((mm = n.match(/^gpt-(\d+(?:[.-]\d+)*)(?:-(.+))?$/)))
+        return `GPT-${ver(mm[1])}${mm[2] ? " " + mm[2] : ""}`;
+    if ((mm = n.match(/^(o\d+)(?:-(.+))?$/)))
+        return `${mm[1]}${mm[2] ? " " + mm[2] : ""}`;
+    if ((mm = n.match(/^gemini-(\d+(?:[.-]\d+)*)/)))
+        return `Gemini ${ver(mm[1])}`;
+    return name.length > 11 ? name.slice(0, 10) + "…" : name;
+}
+function modelProvider(name) {
+    const n = name.toLowerCase();
+    if (/claude|opus|sonnet|haiku/.test(n))
+        return "anthropic";
+    if (/gpt|^o\d/.test(n))
+        return "openai";
+    if (n.includes("gemini"))
+        return "gemini";
+    return "other";
+}
+function modelProviderColor(provider) {
+    if (provider === "anthropic")
+        return "#ff8a00";
+    if (provider === "openai")
+        return "#00d563";
+    if (provider === "gemini")
+        return "#4f8cff";
+    return "#888888";
+}
+// A 1st/2nd/3rd podium: champion on the tallest center pedestal under a crown,
+// runners-up stepped down on the sides. Pedestals are tinted by provider.
+function cardModelsStack(view) {
+    if (!usageReady(view))
+        return "";
+    const m = view.models;
+    if (!m.top_model)
+        return "";
+    const totalSessions = Math.max(m.by_provider.reduce((s, p) => s + p.sessions, 0), 1);
+    const ranked = m.by_provider
+        .flatMap((p) => p.models)
+        .sort((a, b) => b.sessions - a.sessions)
+        .slice(0, 3)
+        .map((mm, i) => ({
+        name: shortenModelName(mm.name),
+        pct: Math.round((mm.sessions / totalSessions) * 100),
+        prov: modelProvider(mm.name),
+        rank: i + 1,
+    }));
+    if (ranked.length === 0)
+        return "";
+    const [first, second, third] = ranked;
+    const COLW = 12;
+    const blankCol = " ".repeat(COLW);
+    const heights = { 1: 4, 2: 2, 3: 1 };
+    const center = (s, w = COLW) => {
+        if (s.length >= w)
+            return s.slice(0, w);
+        const l = Math.floor((w - s.length) / 2);
+        return " ".repeat(l) + s + " ".repeat(w - s.length - l);
+    };
+    // Build a pedestal column top→bottom: [name, pct, cap, body…, base]. Text is
+    // centered BEFORE coloring so chalk's ANSI codes don't break the width math.
+    const column = (mm) => {
+        if (!mm)
+            return [];
+        const c = modelProviderColor(mm.prov);
+        const hex = (s) => chalk.hex(c)(s);
+        const cap = " " + hex("╭" + "─".repeat(8) + "╮") + " ";
+        const base = " " + hex("╰" + "─".repeat(8) + "╯") + " ";
+        const side = " " + hex("│") + " ".repeat(8) + hex("│") + " ";
+        const num = " " +
+            hex("│") +
+            chalk.bold.white(center("#" + mm.rank, 8)) +
+            hex("│") +
+            " ";
+        const h = heights[mm.rank];
+        const mid = Math.floor((h - 1) / 2);
+        const body = [];
+        for (let i = 0; i < h; i++)
+            body.push(i === mid ? num : side);
+        const label = mm.rank === 1 ? bigNumber(center(mm.name)) : chalk.white(center(mm.name));
+        return [label, chalk.dim(center(mm.pct + "%")), cap, ...body, base];
+    };
+    // left = #2, center = #1, right = #3; bottom-align so the bases line up.
+    const cols = [column(second), column(first), column(third)];
+    const maxH = Math.max(...cols.map((col) => col.length));
+    const padded = cols.map((col) => Array(maxH - col.length)
+        .fill(blankCol)
+        .concat(col));
+    const header = ranked.length === 1 ? "YOUR MODEL & STACK" : "YOUR MODELS & STACK";
+    const lines = [chalk.dim(header), ""];
+    lines.push("   " + [blankCol, chalk.hex("#ffd700")(center("♛")), blankCol].join(" "));
+    for (let r = 0; r < maxH; r++)
+        lines.push("   " + [padded[0][r], padded[1][r], padded[2][r]].join(" "));
+    lines.push("");
+    lines.push(`   top pick: ${chalk.white(first.name)} ${chalk.dim(`— ${first.pct}% of sessions`)}`);
+    // The "what you built in" line: an LLM read of the dominant languages + real
+    // frameworks (no raw file-type list — it was mostly CI/tooling noise). Wrap
+    // narrow enough that the 3-space indent keeps every line within the box's inner
+    // width (50) — otherwise boxen re-wraps the whole card and trims the podium.
+    if (view.stack_comment) {
+        lines.push("");
+        for (const l of wrapWords(view.stack_comment, 46))
+            lines.push(chalk.italic.white("   " + l));
+    }
+    return box(lines.join("\n"), { borderColor: "magenta" });
+}
+// Net code footprint: are you a Shipper (mostly new code), a Refactorer (rework),
+// or a Cleaner (deletes more than adds)? Red/green +/- line breakdown.
+function cardCodeFootprint(view) {
+    const f = view.code_footprint;
+    if (!f)
+        return "";
+    const max = Math.max(f.lines_added, f.lines_deleted, 1);
+    const netLabel = `${f.net >= 0 ? "+" : ""}${compactNum(f.net)}`;
+    const subhead = f.label === "Cleaner"
+        ? "you delete more than you add. the slop stops with you."
+        : f.label === "Shipper"
+            ? `${f.additive_ratio >= 0 ? Math.round(f.additive_ratio * 100) : 0}% of your churn is brand-new code.`
+            : "you rework as much as you write. nothing ships half-baked.";
+    const lines = [
+        chalk.dim("YOUR CODE FOOTPRINT"),
+        "",
+        `  ${bigNumber(f.label.toUpperCase())}`,
+        "",
+        `  ${chalk.green("+ " + compactNum(f.lines_added).padEnd(7))} ${coloredBar(f.lines_added, max, 22, "#22c55e")} ${chalk.dim("added")}`,
+        `  ${chalk.red("- " + compactNum(f.lines_deleted).padEnd(7))} ${coloredBar(f.lines_deleted, max, 22, "#ef4444")} ${chalk.dim("deleted")}`,
+        "",
+        `  ${chalk.white("net " + netLabel)}  ${chalk.dim("lines since 2024")}`,
+    ];
+    if (f.median_commit_size > 0)
+        lines.push(`  ${chalk.dim(`typical commit ~${compactNum(f.median_commit_size)} lines · biggest ${compactNum(f.biggest_commit_size)}`)}`);
+    lines.push("");
+    if (f.line) {
+        for (const l of wrapWords(f.line, 47))
+            lines.push(chalk.italic.white("  " + l));
+    }
+    else {
+        lines.push(chalk.dim("  " + subhead));
+    }
+    return box(lines.join("\n"), { borderColor: "green" });
+}
+// How many agents you run at once. Open-tab span (idle included) vs the peak and
+// the longest-lived session, plus the share of time juggling 2+ at once.
+function cardConcurrency(view) {
+    const c = view.concurrency;
+    if (!c || c.open_tab_peak <= 1)
+        return "";
+    const days = c.longest_session_hours / 24;
+    const longest = days >= 1.5
+        ? `${days.toFixed(0)} days`
+        : `${Math.round(c.longest_session_hours)}h`;
+    const lines = [
+        chalk.dim("HOW MANY AGENTS YOU JUGGLE"),
+        "",
+        `  ${bigNumber(`~${c.open_tab_avg}`)} ${chalk.white("agents open at once")}`,
+        "",
+        `  ${chalk.white("peak".padEnd(14))} ${chalk.dim(`${c.open_tab_peak} at once`)}`,
+        `  ${chalk.white("longest tab".padEnd(14))} ${chalk.dim(`${longest} open`)}`,
+        `  ${chalk.white("2+ active".padEnd(14))} ${chalk.dim(`${Math.round(c.active_juggle_pct * 100)}% of your coding time`)}`,
+        "",
+    ];
+    if (c.line) {
+        for (const l of wrapWords(c.line, 47))
+            lines.push(chalk.italic.white("  " + l));
+    }
+    else {
+        lines.push(chalk.dim("  a one-agent setup could never."));
+    }
+    return box(lines.join("\n"), { borderColor: "blue" });
+}
+// How you talk to the agent — LLM read of your real messages, plus the cheap
+// counters (question ratio, message length) and the recurring themes.
+// Trim a verbose collaboration signal to a brief clause: drop everything after
+// the first comma / parenthesis / colon (which is usually examples + quotes),
+// then clean-cut to a short length. Also drops privacy-sensitive quoted phrases.
+function briefSignal(text) {
+    // Stop at the first structural break (paren/colon/semicolon/comma/dash) so a
+    // long signal with examples or quotes gets trimmed to its lead clause.
+    let s = text.split(/[(:;,]| - /)[0].trim();
+    if (s.length > 34) {
+        const cut = s.slice(0, 34);
+        const sp = cut.lastIndexOf(" ");
+        s = sp > 18 ? cut.slice(0, sp) : cut;
+    }
+    return s;
+}
+// HOW YOU TALK + HOW YOU VIBE-CODE merged: the witty prompting-style one-liner,
+// the collaboration identity (label + one-line summary + 2 brief signals), the
+// counters, and recurring themes. No verbatim "weirdest ask" quote (privacy).
+function cardTalk(view) {
+    const c = view.conversation;
+    const v = view.collaboration;
+    if ((!c || c.total_prompts < 10) && !v)
+        return "";
+    const lines = [chalk.dim("HOW YOU TALK"), ""];
+    if (c?.line) {
+        for (const l of wrapWords(c.line, 47))
+            lines.push(chalk.italic.white("  " + l));
+        lines.push("");
+    }
+    if (v) {
+        lines.push(`  ${bigNumber(v.style_label)}`);
+        if (v.summary)
+            for (const l of wrapWords(v.summary, 47))
+                lines.push(chalk.white("  " + l));
+        const sigs = [
+            ["reads", v.signals.fact_checking],
+            ["drives", v.signals.autonomy],
+        ]
+            .filter(([, t]) => t)
+            .map(([label, t]) => `  ${chalk.dim(label.padEnd(8))} ${chalk.white(briefSignal(t))}`);
+        if (sigs.length > 0) {
+            lines.push("");
+            lines.push(...sigs);
+        }
+    }
+    if (c) {
+        lines.push("");
+        lines.push(`  ${chalk.white(c.total_prompts.toLocaleString())} ${chalk.dim("prompts")}  ·  ${chalk.white(Math.round(c.question_ratio * 100) + "%")} ${chalk.dim("questions")}  ·  ${chalk.white("~" + c.avg_prompt_chars)} ${chalk.dim("chars")}`);
+        if (c.themes.length > 0)
+            lines.push(`  ${chalk.dim("recurring: " + c.themes.slice(0, 4).join(", "))}`);
+    }
+    return box(lines.join("\n"), { borderColor: "magenta" });
+}
+function card9Reveal(view) {
+    const mascot = MASCOTS[view.mascot_pose] ?? MASCOTS.default;
+    const archetype = bigNumber(view.archetype_label.toUpperCase());
+    const lines = [
+        chalk.dim("                  you are…"),
+        "",
+        chalk.hex("#ff8a00")(mascot),
+        "",
+        `              ${archetype}`,
+        "",
+        `   ${chalk.italic.white(`"${view.zinger}"`)}`,
+        "",
+        chalk.dim("           " + view.share_url),
+    ].join("\n");
+    return box(lines, { borderColor: "yellow" });
+}
+// Finale: the shareable /100. Fuses the cohort ranking and the persona reveal —
+// score + standing + mascot + archetype + zinger + the three score bars + callout.
+export function cardProficiency(view) {
+    const mascot = MASCOTS[view.mascot_pose] ?? MASCOTS.default;
+    const archetype = bigNumber(view.archetype_label.toUpperCase());
+    const p = view.proficiency;
+    // Persona-only fallback when the server didn't compute a score (older payloads).
+    if (!p) {
+        return box([
+            chalk.dim("                  you are…"),
+            "",
+            chalk.hex("#ff8a00")(mascot),
+            "",
+            `              ${archetype}`,
+            "",
+            `   ${chalk.italic.white(`"${view.zinger}"`)}`,
+            "",
+            chalk.dim("           " + view.share_url),
+        ].join("\n"), { borderColor: "yellow" });
+    }
+    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`
+        : view.cohort_size > 0
+            ? `among ${view.cohort_size.toLocaleString()} Standout users so far`
+            : "";
+    const metricRow = (label, value) => value === null
+        ? null
+        : `  ${chalk.white(label.padEnd(12))} ${bar(value, 100, 10)} ${chalk.dim(String(value))}`;
+    // Craft is shown only as its bonus contribution (+N), never its raw score, so
+    // the headline never looks smaller than a sub-bar it's built from.
+    const bars = [
+        metricRow("intensity", p.intensity),
+        metricRow("consistency", p.consistency),
+        p.craft_bonus > 0
+            ? `  ${chalk.white("craft".padEnd(12))} ${chalk.hex("#ff8a00")(`+${p.craft_bonus}`)} ${chalk.dim("clean prompting")}`
+            : null,
+    ].filter((r) => r !== null);
+    // Pre-wrap variable-length copy: a line wider than the box makes boxen re-wrap
+    // the WHOLE card through wrap-ansi, which trims the leading spaces our centering
+    // relies on. Keeping every line within INNER_WIDTH avoids that.
+    const zingerLines = wrapWords(`"${view.zinger}"`, INNER_WIDTH).map((l) => centerText(l, chalk.italic.white));
+    const commentLines = p.comment
+        ? wrapWords(p.comment, INNER_WIDTH - 4).map((l, i) => i === 0
+            ? `  ${chalk.hex("#ff8a00")(">")} ${chalk.white(l)}`
+            : `    ${chalk.white(l)}`)
+        : [];
+    // The tier figure is the hero of the finale — it replaces the mascot pose here
+    // so the card gains a reward reveal without growing taller.
+    const tier = tierForScore(p.score);
+    const lines = [
+        centerBlock(tier.art, chalk.hex("#ff8a00")),
+        "",
+        centerText(`──  ${tier.label}  ──`, bigNumber),
+        centerText(`${p.score} / 100`, bigNumber),
+        cohort ? centerText(cohort, chalk.dim) : null,
+        "",
+        centerText(view.archetype_label, chalk.bold.hex("#ad5cff")),
+        ...zingerLines,
+        "",
+        ...bars,
+        ...commentLines,
+        "",
+        centerText(view.share_url, chalk.dim),
+    ].filter((l) => l !== null);
+    return box(lines.join("\n"), { borderColor: "yellow" });
+}
+// Instant stats from local logs — shown before submit. The personality cards
+// (rhythm, models+stack, footprint, etc.) moved to the finale so they can carry
+// their LLM one-liners; the preview is the quick raw-numbers teaser.
+const PREVIEW_CARDS = [
+    card1Open,
+    cardAllTime,
+    cardTokens,
+    cardToolRelationship,
+];
+// Server-enriched cards — shown as the finale once createWrapped returns: top
+// projects (README blurbs), when-you-code rhythm, footprint, concurrency, the
+// models+stack podium, how-you-talk, collaboration, AI-native, standing, reveal.
+// The combined cards carry their LLM lines here.
+const FINALE_CARDS = [
+    cardProjects,
+    cardRhythm,
+    cardCodeFootprint,
+    cardConcurrency,
+    cardModelsStack,
+    cardTalk,
+    card7AINative,
+    cardProficiency,
+];
+function getCardFns(mode) {
+    if (mode === "preview")
+        return PREVIEW_CARDS;
+    if (mode === "finale")
+        return FINALE_CARDS;
+    return [...PREVIEW_CARDS, ...FINALE_CARDS];
+}
+export function buildRenderableCards(view, mode = "final") {
+    return getCardFns(mode)
+        .map((fn) => fn(view))
+        .filter((s) => s.length > 0);
+}
+export async function renderWrapped(view) {
+    return renderWrappedCards(view, "final");
+}
+export async function renderWrappedPreview(view) {
+    return renderWrappedCards(view, "preview");
+}
+// Single-pass render: everything is generated up front (during the spinner), then
+// the user pages the WHOLE deck (banner + all cards) with ↵. No share prompt - the
+// CLI runs that separately. Returns whether the user quit early.
+export async function renderWrappedAll(view) {
+    process.stdout.write("\n");
+    process.stdout.write("  " + TITLE_GRADIENT.multiline("░▒▓ STANDOUT WRAPPED ▓▒░") + "\n");
+    process.stdout.write(chalk.dim(`  ${view.name.toLowerCase()} · last 30 days\n\n`));
+    const cards = buildRenderableCards(view, "final");
+    if (cards.length === 0) {
+        process.stderr.write("  No complete local AI coding activity found yet.\n");
+        return { cancelled: false };
+    }
+    for (let i = 0; i < cards.length; i++) {
+        process.stdout.write(cards[i]);
+        process.stdout.write(divider(`[${i + 1}/${cards.length}]`));
+        if (i === cards.length - 1)
+            break;
+        const key = await waitForKey();
+        if (key === "q" || key === "Q")
+            return { cancelled: true };
+    }
+    return { cancelled: false };
+}
+async function renderWrappedCards(view, mode) {
+    // Title banner
+    process.stdout.write("\n");
+    process.stdout.write("  " + TITLE_GRADIENT.multiline("░▒▓ STANDOUT WRAPPED ▓▒░") + "\n");
+    process.stdout.write(chalk.dim(`  ${view.name.toLowerCase()} · last 30 days\n\n`));
+    // Render each card; cards that return empty string get skipped (e.g. tool
+    // relationship when there's not enough data, models when no model captured).
+    let rendered = 0;
+    const renderable = buildRenderableCards(view, mode);
+    if (renderable.length === 0) {
+        process.stderr.write("  No complete local AI coding activity found yet; skipping instant cards.\n");
+        return { shared: false, cancelled: false };
+    }
+    for (let i = 0; i < renderable.length; i++) {
+        const isLast = i === renderable.length - 1;
+        process.stdout.write(renderable[i]);
+        rendered = i + 1;
+        process.stdout.write(divider(`[${rendered}/${renderable.length}]`));
+        if (isLast)
+            break;
+        const key = await waitForKey();
+        if (key === "q" || key === "Q") {
+            return { shared: false, cancelled: true };
+        }
+    }
+    if (mode === "preview") {
+        return { shared: false, cancelled: false };
+    }
+    // Share prompt
+    process.stdout.write("\n");
+    const ans = await askLine(chalk.white("  share to X? [Y/n] "));
+    process.stdout.write("\n");
+    const shared = !ans || ans.toLowerCase() !== "n";
+    return { shared, cancelled: false };
+}