vibechk 0.1.0

package/dist/cli.js

@@ -0,0 +1,2553 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/storage/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+function ensureDir() {
+  if (!existsSync(VIBECHK_DIR)) {
+    mkdirSync(VIBECHK_DIR, { recursive: true, mode: 448 });
+  }
+}
+function dataExists() {
+  return existsSync(PROFILE_PATH);
+}
+var VIBECHK_SERVER, VIBECHK_DIR, PROFILE_PATH, STREAK_PATH, ACTIVITY_PATH, BADGES_PATH, LEADERBOARD_CACHE_PATH, FRIENDS_PATH, GIST_TOKEN_PATH;
+var init_paths = __esm({
+  "src/storage/paths.ts"() {
+    "use strict";
+    VIBECHK_SERVER = process.env.VIBECHK_SERVER ? process.env.VIBECHK_SERVER.replace(/\/$/, "") : null;
+    VIBECHK_DIR = join(homedir(), ".vibechk");
+    PROFILE_PATH = join(VIBECHK_DIR, "profile.json");
+    STREAK_PATH = join(VIBECHK_DIR, "streak.json");
+    ACTIVITY_PATH = join(VIBECHK_DIR, "activity.jsonl");
+    BADGES_PATH = join(VIBECHK_DIR, "badges.json");
+    LEADERBOARD_CACHE_PATH = join(VIBECHK_DIR, "leaderboard.json");
+    FRIENDS_PATH = join(VIBECHK_DIR, "friends.json");
+    GIST_TOKEN_PATH = join(VIBECHK_DIR, "gist-token");
+  }
+});
+
+// src/storage/atomic.ts
+import { writeFileSync, readFileSync, existsSync as existsSync2, renameSync, appendFileSync } from "fs";
+import { randomBytes } from "crypto";
+function writeJson(filePath, data) {
+  const tmp = filePath + ".tmp." + randomBytes(6).toString("hex");
+  writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+  renameSync(tmp, filePath);
+}
+function readJson(filePath) {
+  if (!existsSync2(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var init_atomic = __esm({
+  "src/storage/atomic.ts"() {
+    "use strict";
+  }
+});
+
+// src/storage/profile-store.ts
+var profile_store_exports = {};
+__export(profile_store_exports, {
+  loadProfile: () => loadProfile,
+  requireProfile: () => requireProfile,
+  saveProfile: () => saveProfile
+});
+function loadProfile() {
+  return readJson(PROFILE_PATH);
+}
+function saveProfile(profile) {
+  ensureDir();
+  writeJson(PROFILE_PATH, profile);
+}
+function requireProfile() {
+  const profile = loadProfile();
+  if (!profile) {
+    throw new Error(
+      "No vibechk profile found. Run `vibechk init` to get started."
+    );
+  }
+  return profile;
+}
+var init_profile_store = __esm({
+  "src/storage/profile-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+  }
+});
+
+// src/storage/streak-store.ts
+function loadStreak() {
+  return readJson(STREAK_PATH) ?? { ...DEFAULT_STREAK };
+}
+function saveStreak(streak) {
+  ensureDir();
+  writeJson(STREAK_PATH, streak);
+}
+var DEFAULT_STREAK;
+var init_streak_store = __esm({
+  "src/storage/streak-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    DEFAULT_STREAK = {
+      currentStreak: 0,
+      longestStreak: 0,
+      lastActivityDate: null,
+      lastCheckInAt: null,
+      freezeTokens: 2,
+      totalCheckIns: 0,
+      graceUsedAt: null,
+      status: "new"
+    };
+  }
+});
+
+// src/core/date-utils.ts
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+import timezone from "dayjs/plugin/timezone.js";
+function todayInTz(tz) {
+  return dayjs().tz(tz).format("YYYY-MM-DD");
+}
+function dateInTz(isoTimestamp, tz) {
+  return dayjs(isoTimestamp).tz(tz).format("YYYY-MM-DD");
+}
+function daysBetween(a, b) {
+  const da = dayjs(a, "YYYY-MM-DD");
+  const db = dayjs(b, "YYYY-MM-DD");
+  return db.diff(da, "day");
+}
+function secondsUntilMidnight(tz) {
+  const now = dayjs().tz(tz);
+  const midnight = now.endOf("day");
+  return midnight.diff(now, "second");
+}
+function formatCountdown(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function friendlyDate(date) {
+  return dayjs(date, "YYYY-MM-DD").format("MMMM D, YYYY");
+}
+function systemTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+var init_date_utils = __esm({
+  "src/core/date-utils.ts"() {
+    "use strict";
+    dayjs.extend(utc);
+    dayjs.extend(timezone);
+  }
+});
+
+// src/storage/activity-store.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+function appendActivity(entry) {
+  ensureDir();
+  const line = JSON.stringify(entry) + "\n";
+  appendFileSync2(ACTIVITY_PATH, line, { encoding: "utf8", mode: 384 });
+}
+function loadActivity() {
+  if (!existsSync4(ACTIVITY_PATH)) return [];
+  try {
+    const content = readFileSync3(ACTIVITY_PATH, "utf8");
+    return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+var init_activity_store = __esm({
+  "src/storage/activity-store.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/storage/badge-store.ts
+function loadBadges() {
+  return readJson(BADGES_PATH) ?? { ...DEFAULT_BADGES };
+}
+function saveBadges(badges) {
+  ensureDir();
+  writeJson(BADGES_PATH, badges);
+}
+function appendBadges(newBadges) {
+  if (newBadges.length === 0) return;
+  const current = loadBadges();
+  current.earned.push(...newBadges);
+  saveBadges(current);
+}
+var DEFAULT_BADGES;
+var init_badge_store = __esm({
+  "src/storage/badge-store.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    DEFAULT_BADGES = { earned: [] };
+  }
+});
+
+// src/core/milestone-checker.ts
+function getAllMilestones() {
+  return MILESTONES;
+}
+function checkNewMilestones(newStreak, badges) {
+  const all = getAllMilestones();
+  const earnedIds = new Set(badges.earned.map((b) => b.milestoneId));
+  return all.filter((m) => m.streakRequired <= newStreak && !earnedIds.has(m.id));
+}
+function createEarnedBadges(milestones, streak, nowIso2) {
+  return milestones.map((m) => ({
+    milestoneId: m.id,
+    earnedAt: nowIso2,
+    streakAtEarning: streak
+  }));
+}
+function totalFreezeReward(milestones) {
+  return milestones.reduce((sum, m) => sum + m.freezeTokenReward, 0);
+}
+var MILESTONES;
+var init_milestone_checker = __esm({
+  "src/core/milestone-checker.ts"() {
+    "use strict";
+    MILESTONES = [
+      { id: "streak_3", name: "Warming Up", description: "3 days of vibe coding", streakRequired: 3, icon: "\u{1F331}", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_7", name: "Week Warrior", description: "7 days straight \u2014 that's a real habit", streakRequired: 7, icon: "\u26A1", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_14", name: "Fortnight Coder", description: "Two weeks of consistent vibe coding", streakRequired: 14, icon: "\u{1F680}", rarity: "common", freezeTokenReward: 0 },
+      { id: "streak_30", name: "Monthly Builder", description: "A full month of showing up every day", streakRequired: 30, icon: "\u{1F3C6}", rarity: "rare", freezeTokenReward: 1 },
+      { id: "streak_60", name: "Two Month Grind", description: "60 days \u2014 you're not messing around", streakRequired: 60, icon: "\u{1F48E}", rarity: "rare", freezeTokenReward: 1 },
+      { id: "streak_90", name: "Quarter Strong", description: "Three months of daily vibe coding", streakRequired: 90, icon: "\u{1F525}", rarity: "epic", freezeTokenReward: 1 },
+      { id: "streak_100", name: "Triple Digits", description: "100 days. This is who you are.", streakRequired: 100, icon: "\u{1F4AF}", rarity: "epic", freezeTokenReward: 0 },
+      { id: "streak_180", name: "Half Year Vibe", description: "Six months of consistent AI-assisted coding", streakRequired: 180, icon: "\u{1F31F}", rarity: "legendary", freezeTokenReward: 0 },
+      { id: "streak_365", name: "Year of the Vibe", description: "365 days. Legendary status achieved.", streakRequired: 365, icon: "\u{1F451}", rarity: "legendary", freezeTokenReward: 0 }
+    ];
+  }
+});
+
+// src/storage/friends-store.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "fs";
+function getPublishEndpoint() {
+  if (VIBECHK_SERVER) return VIBECHK_SERVER;
+  return loadFriends().publishEndpoint ?? null;
+}
+function loadFriends() {
+  if (!existsSync7(FRIENDS_PATH)) return { ...DEFAULT };
+  try {
+    return JSON.parse(readFileSync5(FRIENDS_PATH, "utf8"));
+  } catch {
+    return { ...DEFAULT };
+  }
+}
+function saveFriends(data) {
+  ensureDir();
+  writeFileSync3(FRIENDS_PATH, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+}
+function getFriendByAlias(alias) {
+  const { friends } = loadFriends();
+  return friends.find((f) => f.alias.toLowerCase() === alias.toLowerCase()) ?? null;
+}
+function loadGistToken() {
+  if (!existsSync7(GIST_TOKEN_PATH)) return null;
+  try {
+    const t = readFileSync5(GIST_TOKEN_PATH, "utf8").trim();
+    return t || null;
+  } catch {
+    return null;
+  }
+}
+function saveGistToken(token) {
+  ensureDir();
+  writeFileSync3(GIST_TOKEN_PATH, token, { encoding: "utf8", mode: 384 });
+}
+var DEFAULT;
+var init_friends_store = __esm({
+  "src/storage/friends-store.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT = {
+      version: 1,
+      friends: [],
+      myPublishUrl: null,
+      gistId: null,
+      publishEndpoint: null
+    };
+  }
+});
+
+// src/commands/publish.ts
+var publish_exports = {};
+__export(publish_exports, {
+  buildPublicProfile: () => buildPublicProfile,
+  runPublish: () => runPublish
+});
+import chalk4 from "chalk";
+import { input as input2 } from "@inquirer/prompts";
+function buildPublicProfile(username, currentStreak, longestStreak, lastActiveDate, totalCheckIns, badges, activeLast30) {
+  return {
+    version: 1,
+    username,
+    currentStreak,
+    longestStreak,
+    lastActiveDate,
+    consistencyLast30: Math.round(activeLast30 / 30 * 100),
+    totalCheckIns,
+    badges,
+    publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function runPublish(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const today = todayInTz(profile.timezone);
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 29);
+  const cutoff = thirtyDaysAgo.toISOString().slice(0, 10);
+  const activeLast30 = activity.filter((a) => a.date >= cutoff && a.date <= today).length;
+  const payload = buildPublicProfile(
+    profile.username,
+    streak.currentStreak,
+    streak.longestStreak,
+    streak.lastActivityDate,
+    streak.totalCheckIns,
+    badges.earned.map((b) => b.milestoneId),
+    activeLast30
+  );
+  const json = JSON.stringify(payload, null, 2);
+  if (options.stdout) {
+    console.log(json);
+    return null;
+  }
+  if (options.gist) {
+    return publishToGist(profile, json, options);
+  }
+  const endpoint = options.endpoint ? options.endpoint.replace(/\/$/, "") : getPublishEndpoint();
+  if (endpoint) {
+    return publishToEndpoint(profile, json, endpoint, options.silent ?? false);
+  }
+  return publishToGist(profile, json, options);
+}
+async function publishToEndpoint(profile, json, endpoint, silent) {
+  try {
+    if (!silent) process.stdout.write(chalk4.dim(`  Publishing to ${endpoint}...`));
+    const res = await fetch(`${endpoint}/api/users/${profile.id}`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${profile.id}`,
+        "User-Agent": "vibechk/0.1.0"
+      },
+      body: json,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) throw new Error(`${res.status}: ${res.statusText}`);
+    const data = await res.json();
+    const friends = loadFriends();
+    friends.myPublishUrl = data.jsonUrl;
+    friends.publishEndpoint = endpoint;
+    saveFriends(friends);
+    if (!silent) {
+      console.log(chalk4.green(" \u2713"));
+      console.log("");
+      console.log(`  ${chalk4.bold("Your profile:")} ${chalk4.cyan(data.url)}`);
+      console.log("");
+      console.log(chalk4.dim("  Friends on the same server can add you by username:"));
+      console.log(chalk4.dim(`    vibechk friend add ${profile.username}`));
+      console.log("");
+      console.log(chalk4.dim("  Or share your direct URL:"));
+      console.log(chalk4.dim(`    vibechk friend add ${profile.username} ${data.jsonUrl}`));
+      console.log("");
+    }
+    return data.jsonUrl;
+  } catch (err) {
+    if (!silent) {
+      console.log(chalk4.red(` \u2717 ${err.message}`));
+      console.log(chalk4.dim("\n  Check that the endpoint is reachable and supports the vibechk API."));
+      console.log(chalk4.dim("  Use --gist to publish via GitHub Gist instead."));
+    }
+    return null;
+  }
+}
+async function publishToGist(profile, json, options) {
+  let token = options.token ?? loadGistToken();
+  if (!token) {
+    if (options.silent) return null;
+    console.log("");
+    console.log(chalk4.bold("  Publish your streak via GitHub Gist"));
+    console.log("");
+    console.log(chalk4.dim("  This creates a public JSON file that friends can subscribe to."));
+    console.log(chalk4.dim("  You need a GitHub personal access token with the `gist` scope."));
+    console.log("");
+    console.log(chalk4.dim("  1. Go to https://github.com/settings/tokens/new?scopes=gist"));
+    console.log(chalk4.dim('  2. Create a token with just the "gist" scope'));
+    console.log(chalk4.dim("  3. Paste it below"));
+    console.log("");
+    token = await input2({ message: "GitHub token (gist scope):" });
+    if (!token.trim()) {
+      console.log(chalk4.dim("  Skipped. Run `vibechk publish` again when ready."));
+      return null;
+    }
+    saveGistToken(token.trim());
+    token = token.trim();
+  }
+  const friends = loadFriends();
+  try {
+    if (!options.silent) process.stdout.write(chalk4.dim("  Publishing to Gist..."));
+    const { gistId, rawUrl } = friends.gistId ? await updateGist(friends.gistId, json, token) : await createGist(json, token);
+    friends.gistId = gistId;
+    friends.myPublishUrl = rawUrl;
+    saveFriends(friends);
+    if (!options.silent) {
+      console.log(chalk4.green(" \u2713"));
+      console.log("");
+      console.log(`  ${chalk4.bold("Your friend URL:")} ${chalk4.cyan(rawUrl)}`);
+      console.log("");
+      console.log(chalk4.dim("  Share this URL with friends so they can follow your streak:"));
+      console.log(chalk4.dim(`    vibechk friend add ${profile.username} ${rawUrl}`));
+      console.log("");
+    }
+    return rawUrl;
+  } catch (err) {
+    if (!options.silent) {
+      console.log(chalk4.red(` \u2717 ${err.message}`));
+      if (err.message.includes("401") || err.message.includes("403")) {
+        console.log(chalk4.dim("\n  Token may be expired or missing the gist scope."));
+        console.log(chalk4.dim("  Delete ~/.vibechk/gist-token and run `vibechk publish` again."));
+      }
+    }
+    return null;
+  }
+}
+async function createGist(json, token) {
+  const res = await fetch(`${GIST_API}/gists`, {
+    method: "POST",
+    headers: gistHeaders(token),
+    body: JSON.stringify({
+      description: "vibechk \u2014 my vibe coding streak",
+      public: true,
+      files: { [GIST_FILENAME]: { content: json } }
+    }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${res.statusText}`);
+  const data = await res.json();
+  const login = data.owner?.login ?? "me";
+  const rawUrl = `https://gist.githubusercontent.com/${login}/${data.id}/raw/${GIST_FILENAME}`;
+  return { gistId: data.id, rawUrl, login };
+}
+async function updateGist(gistId, json, token) {
+  const res = await fetch(`${GIST_API}/gists/${gistId}`, {
+    method: "PATCH",
+    headers: gistHeaders(token),
+    body: JSON.stringify({
+      files: { [GIST_FILENAME]: { content: json } }
+    }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) throw new Error(`GitHub API ${res.status}: ${res.statusText}`);
+  const data = await res.json();
+  const login = data.owner?.login ?? "me";
+  const rawUrl = `https://gist.githubusercontent.com/${login}/${data.id}/raw/${GIST_FILENAME}`;
+  return { gistId: data.id, rawUrl, login };
+}
+function gistHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "Content-Type": "application/json",
+    "User-Agent": "vibechk/0.1.0",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+}
+var GIST_API, GIST_FILENAME;
+var init_publish = __esm({
+  "src/commands/publish.ts"() {
+    "use strict";
+    init_profile_store();
+    init_streak_store();
+    init_activity_store();
+    init_badge_store();
+    init_friends_store();
+    init_date_utils();
+    GIST_API = "https://api.github.com";
+    GIST_FILENAME = "vibechk.json";
+  }
+});
+
+// src/commands/friend.ts
+var friend_exports = {};
+__export(friend_exports, {
+  runFriendAdd: () => runFriendAdd,
+  runFriendList: () => runFriendList,
+  runFriendPull: () => runFriendPull,
+  runFriendRemove: () => runFriendRemove
+});
+import chalk5 from "chalk";
+async function runFriendAdd(alias, url) {
+  const normalized = alias.trim().toLowerCase();
+  if (!normalized || !/^[\w\-\.]+$/.test(normalized)) {
+    console.error(chalk5.red("  Alias must be letters, numbers, - or _ only."));
+    process.exit(1);
+  }
+  const existing = getFriendByAlias(normalized);
+  if (existing) {
+    console.log(chalk5.yellow(`  Already following "${normalized}" at ${existing.url}`));
+    console.log(chalk5.dim(`  Use \`vibechk friend remove ${normalized}\` first to replace them.`));
+    return;
+  }
+  let resolvedUrl;
+  if (url?.trim()) {
+    resolvedUrl = url.trim();
+  } else {
+    const endpoint = getPublishEndpoint();
+    if (endpoint) {
+      resolvedUrl = `${endpoint}/u/${normalized}.json`;
+    } else {
+      console.error(chalk5.red("  No URL provided and no remote endpoint configured."));
+      console.log("");
+      console.log(chalk5.dim("  Provide the friend's profile URL:"));
+      console.log(chalk5.dim(`    vibechk friend add ${normalized} https://...`));
+      console.log("");
+      console.log(chalk5.dim("  Or set a remote endpoint via the VIBECHK_SERVER env var."));
+      process.exit(1);
+    }
+  }
+  const data = loadFriends();
+  const entry = {
+    alias: normalized,
+    url: resolvedUrl,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastFetchedAt: null,
+    cached: null
+  };
+  data.friends.push(entry);
+  saveFriends(data);
+  console.log(chalk5.green(`
+  \u2713 Added ${normalized}.`));
+  console.log(chalk5.dim("  Fetching their streak now...\n"));
+  const result = await fetchOneFriend(entry);
+  if (result.cached) {
+    printFriendRow(result, todayInTz(requireProfile().timezone), true);
+  } else {
+    console.log(chalk5.yellow(`  Could not fetch their data: ${result.lastFetchError ?? "unknown error"}`));
+    console.log(chalk5.dim("  Their data will be retried on the next `vibechk friend pull`."));
+  }
+  console.log("");
+}
+function runFriendRemove(alias) {
+  const normalized = alias.trim().toLowerCase();
+  const data = loadFriends();
+  const idx = data.friends.findIndex((f) => f.alias.toLowerCase() === normalized);
+  if (idx === -1) {
+    console.log(chalk5.yellow(`  No friend found with alias "${normalized}".`));
+    return;
+  }
+  data.friends.splice(idx, 1);
+  saveFriends(data);
+  console.log(chalk5.green(`
+  \u2713 Removed ${normalized}.
+`));
+}
+async function runFriendPull(options = {}) {
+  const data = loadFriends();
+  if (data.friends.length === 0) {
+    if (!options.quiet) {
+      console.log(chalk5.dim("\n  No friends added yet. Run `vibechk friend add <alias> <url>`.\n"));
+    }
+    return;
+  }
+  if (!options.quiet) process.stdout.write(chalk5.dim(`  Syncing ${data.friends.length} friend(s)...`));
+  const updated = await Promise.all(data.friends.map(fetchOneFriend));
+  data.friends = updated;
+  saveFriends(data);
+  if (!options.quiet) {
+    const ok = updated.filter((f) => f.cached !== null).length;
+    console.log(chalk5.green(` ${ok}/${updated.length} updated.
+`));
+  }
+}
+async function runFriendList() {
+  const profile = requireProfile();
+  const myStreak = loadStreak();
+  const today = todayInTz(profile.timezone);
+  let data = loadFriends();
+  if (data.friends.length === 0) {
+    console.log("");
+    console.log(chalk5.dim("  No friends yet.\n"));
+    console.log("  Share your streak URL with friends and add theirs:");
+    if (data.myPublishUrl) {
+      console.log("");
+      console.log(`  Your URL: ${chalk5.cyan(data.myPublishUrl)}`);
+    } else {
+      console.log(chalk5.dim("  Run `vibechk publish` to generate your shareable URL first."));
+    }
+    console.log(chalk5.dim("\n  vibechk friend add <alias> <their-url>\n"));
+    return;
+  }
+  const needsRefresh = data.friends.some((f) => isStale(f) || !f.lastFetchedAt);
+  if (needsRefresh) {
+    process.stdout.write(chalk5.dim(`  Refreshing ${data.friends.length} friend(s)...`));
+    const updated = await Promise.all(data.friends.map(fetchOneFriend));
+    data.friends = updated;
+    saveFriends(data);
+    const ok = updated.filter((f) => f.cached !== null).length;
+    console.log(chalk5.green(` ${ok}/${updated.length} updated.`));
+  }
+  console.log("");
+  const sorted = [...data.friends].sort((a, b) => {
+    const aToday = a.cached?.lastActiveDate === today ? 1 : 0;
+    const bToday = b.cached?.lastActiveDate === today ? 1 : 0;
+    if (bToday !== aToday) return bToday - aToday;
+    return (b.cached?.currentStreak ?? -1) - (a.cached?.currentStreak ?? -1);
+  });
+  const COL = { alias: 14, streak: 9, today: 8, consistency: 8, best: 7 };
+  const header = chalk5.dim(padR("  name", COL.alias)) + chalk5.dim(padR("streak", COL.streak)) + chalk5.dim(padR("today", COL.today)) + chalk5.dim(padR("30d%", COL.consistency)) + chalk5.dim("best");
+  console.log(header);
+  console.log(chalk5.dim("  " + "\u2500".repeat(48)));
+  for (const friend of sorted) {
+    printFriendRow(friend, today, false);
+  }
+  console.log(chalk5.dim("  " + "\u2500".repeat(48)));
+  const myCheckedIn = myStreak.lastActivityDate === today;
+  const myEmoji = myStreak.currentStreak >= 30 ? "\u{1F3C6}" : myStreak.currentStreak > 0 ? "\u{1F525}" : "\u{1F331}";
+  const myTodayLabel = myCheckedIn ? chalk5.green("\u2713") : chalk5.yellow("\u25CB");
+  console.log(
+    padR(`  ${chalk5.bold("you")}`, COL.alias) + padR(`${myEmoji} ${myStreak.currentStreak}d`, COL.streak) + padR(myTodayLabel, COL.today) + padR(chalk5.dim("\u2014"), COL.consistency) + chalk5.dim(`${myStreak.longestStreak}d`)
+  );
+  console.log("");
+  if (data.friends.some((f) => f.lastFetchedAt)) {
+    const oldest = data.friends.filter((f) => f.lastFetchedAt).sort((a, b) => a.lastFetchedAt.localeCompare(b.lastFetchedAt)).at(0);
+    const age = Math.round((Date.now() - new Date(oldest.lastFetchedAt).getTime()) / 6e4);
+    console.log(chalk5.dim(`  Last synced: ${age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`}`));
+  }
+  if (data.myPublishUrl) {
+    console.log(chalk5.dim(`  Your URL: ${data.myPublishUrl}`));
+  } else {
+    console.log(chalk5.dim("  Run `vibechk publish` so friends can follow you."));
+  }
+  console.log("");
+}
+async function fetchOneFriend(entry) {
+  try {
+    const res = await fetch(entry.url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      headers: { "User-Agent": "vibechk/0.1.0", Accept: "application/json" }
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const json = await res.json();
+    if (typeof json.username !== "string" || typeof json.currentStreak !== "number") {
+      throw new Error("Invalid profile format");
+    }
+    return {
+      ...entry,
+      lastFetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastFetchError: void 0,
+      cached: json
+    };
+  } catch (err) {
+    return {
+      ...entry,
+      lastFetchError: err.message ?? "fetch failed"
+      // preserve old cached data — stale is better than empty
+    };
+  }
+}
+function printFriendRow(friend, today, verbose) {
+  const c = friend.cached;
+  const COL = { alias: 14, streak: 9, today: 8, consistency: 8 };
+  if (!c) {
+    const errLabel = friend.lastFetchError ? chalk5.red(`\u26A0 ${friend.lastFetchError.slice(0, 30)}`) : chalk5.dim("fetching...");
+    console.log(padR(`  ${chalk5.bold(friend.alias)}`, COL.alias) + errLabel);
+    return;
+  }
+  const streakEmoji = c.currentStreak >= 30 ? "\u{1F3C6}" : c.currentStreak > 0 ? "\u{1F525}" : "\u{1F331}";
+  const checkedInToday = c.lastActiveDate === today;
+  const todayLabel = checkedInToday ? chalk5.green("\u2713") : chalk5.dim("\u25CB");
+  const consistencyColor = c.consistencyLast30 >= 80 ? chalk5.green : c.consistencyLast30 >= 50 ? chalk5.yellow : chalk5.red;
+  const prevNote = c.longestStreak > c.currentStreak && c.longestStreak > 0 ? chalk5.dim(` prev ${c.longestStreak}d`) : "";
+  const staleNote = isStale(friend) ? chalk5.yellow(" \u26A0") : "";
+  const theirName = c.username !== friend.alias ? chalk5.dim(` (${c.username})`) : "";
+  if (verbose) {
+    console.log(`  ${streakEmoji} ${chalk5.bold(friend.alias)}${theirName}: ${chalk5.yellow.bold(c.currentStreak + " days")}`);
+    console.log(`     Today: ${checkedInToday ? chalk5.green("checked in \u2713") : chalk5.dim("not yet \u25CB")}`);
+    console.log(`     30-day consistency: ${consistencyColor(c.consistencyLast30 + "%")}`);
+    console.log(`     Best streak: ${c.longestStreak}d   Check-ins: ${c.totalCheckIns}`);
+    const milestones = getAllMilestones();
+    const earned = c.badges.map((id) => milestones.find((m) => m.id === id)?.icon ?? "").filter(Boolean);
+    if (earned.length) console.log(`     Badges: ${earned.join(" ")}`);
+  } else {
+    console.log(
+      padR(`  ${chalk5.bold(friend.alias)}${theirName}`, COL.alias) + padR(`${streakEmoji} ${c.currentStreak}d${prevNote}`, COL.streak) + padR(todayLabel, COL.today) + padR(consistencyColor(c.consistencyLast30 + "%"), COL.consistency) + chalk5.dim(c.longestStreak + "d") + staleNote
+    );
+  }
+}
+function isStale(friend) {
+  if (!friend.lastFetchedAt) return false;
+  const ageMs = Date.now() - new Date(friend.lastFetchedAt).getTime();
+  return ageMs > STALE_HOURS * 3600 * 1e3;
+}
+function padR(s, width) {
+  const plainLen = s.replace(/\x1B\[[0-9;]*m/g, "").length;
+  const pad = Math.max(0, width - plainLen);
+  return s + " ".repeat(pad);
+}
+var FETCH_TIMEOUT_MS, STALE_HOURS;
+var init_friend = __esm({
+  "src/commands/friend.ts"() {
+    "use strict";
+    init_friends_store();
+    init_profile_store();
+    init_streak_store();
+    init_date_utils();
+    init_milestone_checker();
+    FETCH_TIMEOUT_MS = 8e3;
+    STALE_HOURS = 25;
+  }
+});
+
+// src/cli.ts
+init_paths();
+import { Command } from "commander";
+import chalk14 from "chalk";
+
+// src/commands/init.ts
+init_profile_store();
+init_streak_store();
+init_streak_store();
+init_date_utils();
+import { input, confirm } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import { v4 as uuidv4 } from "uuid";
+
+// src/commands/schedule.ts
+import { execSync } from "child_process";
+import { writeFileSync as writeFileSync2, existsSync as existsSync3, unlinkSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import chalk from "chalk";
+var LAUNCHD_LABEL = "com.vibechk.daily";
+var LAUNCHD_PLIST_PATH = join2(homedir2(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+var CRON_MARKER = "# vibechk-daily";
+async function installSchedule(time, profile) {
+  const [hour, minute] = parseTime(time);
+  const bin = findVibechkBin();
+  if (process.platform === "darwin") {
+    installLaunchd(bin, hour, minute, profile?.timezone);
+  } else {
+    installCron(bin, hour, minute, profile?.timezone);
+  }
+}
+async function uninstallSchedule() {
+  if (process.platform === "darwin") {
+    uninstallLaunchd();
+  } else {
+    uninstallCron();
+  }
+}
+function getScheduleStatus() {
+  if (process.platform === "darwin") {
+    return existsSync3(LAUNCHD_PLIST_PATH) ? `launchd plist: ${LAUNCHD_PLIST_PATH}` : null;
+  }
+  const crontab = readCrontab();
+  return crontab.includes(CRON_MARKER) ? "cron (user crontab)" : null;
+}
+function installLaunchd(bin, hour, minute, timezone3) {
+  if (existsSync3(LAUNCHD_PLIST_PATH)) {
+    try {
+      execSync(`launchctl unload "${LAUNCHD_PLIST_PATH}" 2>/dev/null`, { stdio: "pipe" });
+    } catch {
+    }
+  }
+  const tzEnv = timezone3 ? `
+        <key>EnvironmentVariables</key>
+        <dict>
+          <key>TZ</key>
+          <string>${timezone3}</string>
+        </dict>` : "";
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bin}</string>
+    <string>check-in</string>
+    <string>--no-interactive</string>
+    <string>--quiet</string>
+  </array>
+
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${hour}</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+${tzEnv}
+  <key>StandardOutPath</key>
+  <string>/tmp/vibechk-daily.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/vibechk-daily.log</string>
+
+  <!-- Run at load only if the scheduled time was missed while the machine was off -->
+  <key>RunAtLoad</key>
+  <false/>
+</dict>
+</plist>
+`;
+  writeFileSync2(LAUNCHD_PLIST_PATH, plist, { encoding: "utf8", mode: 420 });
+  execSync(`launchctl load -w "${LAUNCHD_PLIST_PATH}"`, { stdio: "pipe" });
+}
+function uninstallLaunchd() {
+  if (!existsSync3(LAUNCHD_PLIST_PATH)) {
+    console.log(chalk.dim("  No launchd job found."));
+    return;
+  }
+  try {
+    execSync(`launchctl unload -w "${LAUNCHD_PLIST_PATH}"`, { stdio: "pipe" });
+  } catch {
+  }
+  unlinkSync(LAUNCHD_PLIST_PATH);
+  console.log(chalk.green("\u2713 launchd job removed."));
+}
+function installCron(bin, hour, minute, timezone3) {
+  const existing = readCrontab();
+  const cleaned = existing.split("\n").filter((line) => !line.includes(CRON_MARKER)).join("\n").trim();
+  const pathHint = `PATH=/usr/local/bin:/usr/bin:/bin:${join2(homedir2(), ".npm-global/bin")}:${join2(homedir2(), ".local/bin")}`;
+  const tzLine = timezone3 ? `TZ=${timezone3}` : "";
+  const cronLine = `${minute} ${hour} * * * ${bin} check-in --no-interactive --quiet >> /tmp/vibechk-daily.log 2>&1 ${CRON_MARKER}`;
+  const parts = [cleaned, pathHint, tzLine, cronLine].filter(Boolean);
+  const newCrontab = parts.join("\n") + "\n";
+  writeCrontab(newCrontab);
+}
+function uninstallCron() {
+  const existing = readCrontab();
+  if (!existing.includes(CRON_MARKER)) {
+    console.log(chalk.dim("  No cron job found."));
+    return;
+  }
+  const cleaned = existing.split("\n").filter((line) => !line.includes(CRON_MARKER)).join("\n").trimEnd() + "\n";
+  writeCrontab(cleaned);
+  console.log(chalk.green("\u2713 Cron job removed."));
+}
+function readCrontab() {
+  try {
+    return execSync("crontab -l 2>/dev/null", { encoding: "utf8" });
+  } catch {
+    return "";
+  }
+}
+function writeCrontab(content) {
+  const tmp = `/tmp/vibechk-crontab-${Date.now()}`;
+  writeFileSync2(tmp, content, { encoding: "utf8" });
+  try {
+    execSync(`crontab "${tmp}"`, { stdio: "pipe" });
+  } finally {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function parseTime(time) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(time);
+  if (!match) throw new Error(`Invalid time format "${time}". Use HH:MM, e.g. 21:00`);
+  const h = parseInt(match[1], 10);
+  const m = parseInt(match[2], 10);
+  if (h < 0 || h > 23 || m < 0 || m > 59) {
+    throw new Error(`Time out of range. Hour must be 0\u201323, minute 0\u201359.`);
+  }
+  return [h, m];
+}
+function findVibechkBin() {
+  try {
+    const bin = execSync("which vibechk", { encoding: "utf8", stdio: "pipe" }).trim();
+    if (bin) return bin;
+  } catch {
+  }
+  const candidates = [
+    "/usr/local/bin/vibechk",
+    join2(homedir2(), ".npm-global/bin/vibechk"),
+    join2(homedir2(), ".local/bin/vibechk"),
+    join2(homedir2(), ".yarn/bin/vibechk")
+  ];
+  for (const c of candidates) {
+    if (existsSync3(c)) return c;
+  }
+  const nodeExec = process.execPath;
+  const distCli = new URL("../cli.js", import.meta.url).pathname;
+  return `${nodeExec} ${distCli}`;
+}
+async function runSchedule(options) {
+  if (options.status) {
+    const status = getScheduleStatus();
+    if (status) {
+      console.log(chalk.green(`\u2713 Daily auto-check-in is active`));
+      console.log(chalk.dim(`  ${status}`));
+    } else {
+      console.log(chalk.yellow("  No daily schedule is installed."));
+      console.log(chalk.dim("  Run `vibechk schedule` to set it up."));
+    }
+    return;
+  }
+  if (options.remove) {
+    await uninstallSchedule();
+    return;
+  }
+  const time = options.time ?? "21:00";
+  const { requireProfile: requireProfile2 } = await Promise.resolve().then(() => (init_profile_store(), profile_store_exports));
+  const profile = requireProfile2();
+  try {
+    await installSchedule(time, profile);
+    const platform = process.platform === "darwin" ? "launchd" : "cron";
+    console.log("");
+    console.log(chalk.green(`\u2713 Daily auto-check-in scheduled via ${platform}`));
+    console.log(chalk.dim(`  vibechk check-in will run at ${time} every day`));
+    console.log(chalk.dim(`  It detects Claude Code and git commits automatically.`));
+    console.log(chalk.dim(`  Logs: /tmp/vibechk-daily.log`));
+    console.log(chalk.dim(`  To remove: vibechk schedule --remove`));
+    console.log("");
+  } catch (err) {
+    console.error(chalk.red("Failed to install schedule:"), err.message);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+async function runInit() {
+  console.log("");
+  console.log(chalk2.bold("  Welcome to vibechk! \u{1F525}"));
+  console.log(chalk2.dim("  Track your daily vibe coding streaks.\n"));
+  const username = await input({
+    message: "Choose a username (shown on leaderboard):",
+    validate: (v) => {
+      if (!v.trim()) return "Username cannot be empty";
+      if (v.length > 24) return "Max 24 characters";
+      if (!/^[\w\-\.]+$/.test(v)) return "Only letters, numbers, _ - . allowed";
+      return true;
+    }
+  });
+  const detectedTz = systemTimezone();
+  const tzInput = await input({
+    message: "Your timezone (IANA format):",
+    default: detectedTz,
+    validate: (v) => {
+      try {
+        Intl.DateTimeFormat(void 0, { timeZone: v });
+        return true;
+      } catch {
+        return `Invalid timezone. Example: America/New_York`;
+      }
+    }
+  });
+  const share = await confirm({
+    message: "Share your streak on the community leaderboard? (you can change this later)",
+    default: true
+  });
+  const profile = {
+    id: uuidv4(),
+    username: username.trim(),
+    timezone: tzInput,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cloudSync: null,
+    preferences: {
+      shareOnLeaderboard: share,
+      notificationsEnabled: false,
+      notificationTime: "21:00",
+      celebrationLevel: "normal",
+      sessionSources: ["claude-code", "git", "manual"],
+      weekendsCount: true,
+      watchedRepos: []
+    }
+  };
+  saveProfile(profile);
+  saveStreak({ ...DEFAULT_STREAK });
+  console.log("");
+  console.log(chalk2.green(`\u2713 Profile created! Welcome, ${chalk2.bold(profile.username)}.`));
+  console.log("");
+  const scheduleIt = await confirm({
+    message: "Set up automatic daily check-in at 9 PM? (recommended)",
+    default: true
+  });
+  if (scheduleIt) {
+    try {
+      await installSchedule("21:00", profile);
+      console.log(chalk2.green("\u2713 Daily auto-check-in scheduled."));
+      console.log(chalk2.dim("  vibechk will detect your coding sessions automatically each evening."));
+      console.log(chalk2.dim("  Run `vibechk schedule --help` to change the time or disable it."));
+    } catch (err) {
+      console.log(chalk2.yellow(`  Could not install schedule automatically: ${err.message}`));
+      console.log(chalk2.dim("  Run `vibechk schedule` manually to set it up."));
+    }
+  } else {
+    console.log(chalk2.dim("  Run `vibechk schedule` any time to enable automatic daily tracking."));
+  }
+  console.log("");
+  console.log(chalk2.dim(`  Run ${chalk2.white("vibechk")} to check in your first session.
+`));
+}
+
+// src/commands/check-in.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+init_badge_store();
+init_date_utils();
+import chalk6 from "chalk";
+import ora from "ora";
+import { confirm as confirm2 } from "@inquirer/prompts";
+import { v4 as uuidv42 } from "uuid";
+
+// src/core/streak-calculator.ts
+init_date_utils();
+var GRACE_COOLDOWN_DAYS = 14;
+var MAX_FREEZE_TOKENS = 5;
+function calculateStreakImpact(streak, today, useFreeze = false) {
+  const { lastActivityDate, currentStreak, graceUsedAt, freezeTokens } = streak;
+  if (!lastActivityDate) {
+    return { action: "started", newStreak: 1 };
+  }
+  const daysDiff = daysBetween(lastActivityDate, today);
+  if (daysDiff === 0) {
+    return { action: "already_checked_in", newStreak: currentStreak };
+  }
+  if (daysDiff === 1) {
+    return { action: "continued", newStreak: currentStreak + 1 };
+  }
+  if (daysDiff === 2) {
+    const graceAvailable = !graceUsedAt || daysBetween(graceUsedAt, today) >= GRACE_COOLDOWN_DAYS;
+    if (graceAvailable) {
+      return { action: "grace", newStreak: currentStreak + 1, usedGrace: true };
+    }
+    if (useFreeze && freezeTokens > 0) {
+      return { action: "frozen", newStreak: currentStreak + 1, usedFreeze: true };
+    }
+    if (freezeTokens > 0 && !useFreeze) {
+      return {
+        action: "broken",
+        newStreak: 1,
+        previousStreak: currentStreak
+      };
+    }
+  }
+  return {
+    action: "broken",
+    newStreak: 1,
+    previousStreak: currentStreak
+  };
+}
+function applyStreakImpact(current, impact, today, nowIso2) {
+  const newStreak = impact.newStreak;
+  const newLongest = Math.max(current.longestStreak, newStreak);
+  let freezeTokens = current.freezeTokens;
+  if (impact.usedFreeze) {
+    freezeTokens = Math.max(0, freezeTokens - 1);
+  }
+  let graceUsedAt = current.graceUsedAt;
+  if (impact.usedGrace) {
+    graceUsedAt = today;
+  }
+  let status = "active";
+  if (impact.action === "frozen") status = "frozen";
+  else if (impact.action === "grace") status = "grace";
+  else if (impact.action === "broken") status = "broken";
+  else if (impact.action === "started" || impact.action === "continued" || impact.action === "already_checked_in") status = "active";
+  return {
+    ...current,
+    currentStreak: newStreak,
+    longestStreak: newLongest,
+    lastActivityDate: impact.action === "already_checked_in" ? current.lastActivityDate : today,
+    lastCheckInAt: nowIso2,
+    freezeTokens,
+    totalCheckIns: impact.action === "already_checked_in" ? current.totalCheckIns : current.totalCheckIns + 1,
+    graceUsedAt,
+    status
+  };
+}
+function addFreezeTokens(current, toAdd) {
+  return Math.min(MAX_FREEZE_TOKENS, current + toAdd);
+}
+
+// src/commands/check-in.ts
+init_milestone_checker();
+
+// src/detection/claude-code.ts
+init_date_utils();
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync4, statSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { execSync as execSync2 } from "child_process";
+var CLAUDE_PROJECTS_DIR = join3(homedir3(), ".config", "claude", "projects");
+async function detectClaudeCodeUsage(date, timezone3) {
+  const ccusageResult = tryCcusageCli(date);
+  if (ccusageResult) return ccusageResult;
+  return scanJsonlFiles(date, timezone3);
+}
+function tryCcusageCli(date) {
+  try {
+    const output = execSync2(`ccusage daily --date ${date} --json 2>/dev/null`, {
+      timeout: 5e3,
+      encoding: "utf8"
+    });
+    const data = JSON.parse(output);
+    const entries = Array.isArray(data) ? data : [data];
+    const total = entries.reduce((sum, e) => sum + (e.totalTokens || e.tokens || 0), 0);
+    if (total > 0) {
+      return {
+        detected: true,
+        source: "ccusage-cli",
+        agentData: {
+          sessions: entries.length,
+          tokensApprox: total,
+          models: [...new Set(entries.map((e) => e.model).filter(Boolean))]
+        }
+      };
+    }
+    return { detected: false, source: "ccusage-cli" };
+  } catch {
+    return null;
+  }
+}
+function scanJsonlFiles(date, timezone3) {
+  if (!existsSync5(CLAUDE_PROJECTS_DIR)) {
+    return { detected: false, source: "none" };
+  }
+  let sessionCount = 0;
+  let tokenCount = 0;
+  try {
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+    for (const project of projectDirs) {
+      const projectPath = join3(CLAUDE_PROJECTS_DIR, project);
+      if (!statSync(projectPath).isDirectory()) continue;
+      const files = readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filePath = join3(projectPath, file);
+        const content = readFileSync4(filePath, "utf8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        let fileHasActivity = false;
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            const ts = entry.timestamp || entry.createdAt || entry.created_at;
+            if (!ts) continue;
+            const entryDate = dateInTz(ts, timezone3);
+            if (entryDate === date) {
+              fileHasActivity = true;
+              if (typeof entry.usage?.input_tokens === "number") {
+                tokenCount += entry.usage.input_tokens + (entry.usage.output_tokens || 0);
+              } else if (typeof entry.content === "string") {
+                tokenCount += Math.floor(entry.content.length / 4);
+              }
+            }
+          } catch {
+          }
+        }
+        if (fileHasActivity) sessionCount++;
+      }
+    }
+  } catch {
+    return { detected: false, source: "none" };
+  }
+  if (sessionCount > 0) {
+    return {
+      detected: true,
+      source: "jsonl-scan",
+      agentData: { sessions: sessionCount, tokensApprox: tokenCount }
+    };
+  }
+  return { detected: false, source: "jsonl-scan" };
+}
+
+// src/detection/git.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+async function detectGitActivity(date, timezone3, watchedRepos) {
+  const repoPaths = watchedRepos.length > 0 ? watchedRepos.map(expandHome) : discoverRepos();
+  for (const repoPath of repoPaths) {
+    if (!existsSync6(join4(repoPath, ".git"))) continue;
+    try {
+      const since = `${date} 00:00:00`;
+      const until = `${date} 23:59:59`;
+      const result = execSync3(
+        `git -C ${JSON.stringify(repoPath)} log --oneline --after=${JSON.stringify(since)} --before=${JSON.stringify(until)} 2>/dev/null`,
+        { encoding: "utf8", timeout: 5e3, env: { ...process.env, TZ: timezone3 } }
+      ).trim();
+      if (result.length > 0) {
+        return { detected: true, repoPath };
+      }
+    } catch {
+    }
+  }
+  return { detected: false };
+}
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return join4(homedir4(), p.slice(2));
+  }
+  return p;
+}
+function discoverRepos() {
+  const candidates = [
+    homedir4(),
+    join4(homedir4(), "code"),
+    join4(homedir4(), "projects"),
+    join4(homedir4(), "dev"),
+    join4(homedir4(), "workspace"),
+    join4(homedir4(), "src")
+  ];
+  const repos = [];
+  for (const dir of candidates) {
+    if (!existsSync6(dir)) continue;
+    if (existsSync6(join4(dir, ".git"))) {
+      repos.push(dir);
+      continue;
+    }
+    try {
+      const entries = readdirSync2(dir);
+      for (const entry of entries) {
+        const full = join4(dir, entry);
+        try {
+          if (statSync2(full).isDirectory() && existsSync6(join4(full, ".git"))) {
+            repos.push(full);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (repos.length >= 50) break;
+  }
+  return repos;
+}
+
+// src/detection/index.ts
+async function detectTodaySession(date, timezone3, enabledSources, watchedRepos = []) {
+  if (enabledSources.includes("claude-code")) {
+    const result = await detectClaudeCodeUsage(date, timezone3);
+    if (result.detected) {
+      return { detected: true, source: "claude-code", agentData: result.agentData };
+    }
+  }
+  if (enabledSources.includes("git")) {
+    const result = await detectGitActivity(date, timezone3, watchedRepos);
+    if (result.detected) {
+      return { detected: true, source: "git" };
+    }
+  }
+  return { detected: false, source: "manual" };
+}
+
+// src/sync/client.ts
+function makeHeaders(apiKey) {
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKey}`,
+    "User-Agent": "vibechk/0.1.0"
+  };
+}
+function buildSyncPayload(profile, streak, badges) {
+  const totalFreezesUsed = streak.totalCheckIns - streak.currentStreak;
+  return {
+    userId: profile.id,
+    username: profile.username,
+    currentStreak: streak.currentStreak,
+    longestStreak: streak.longestStreak,
+    lastActiveDate: streak.lastActivityDate,
+    freezesUsed: totalFreezesUsed > 0 ? totalFreezesUsed : 0,
+    badges: badges.earned.map((b) => b.milestoneId),
+    shareOnLeaderboard: profile.preferences.shareOnLeaderboard
+  };
+}
+async function pushStreak(profile, streak, badges) {
+  const sync = profile.cloudSync;
+  if (!sync) return false;
+  const payload = buildSyncPayload(profile, streak, badges);
+  try {
+    const response = await fetch(`${sync.endpoint}/users/${profile.id}`, {
+      method: "PUT",
+      headers: makeHeaders(sync.apiKey),
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(8e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function fetchLeaderboard(profile) {
+  const sync = profile.cloudSync;
+  if (!sync) return null;
+  try {
+    const response = await fetch(`${sync.endpoint}/leaderboard`, {
+      headers: makeHeaders(sync.apiKey),
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const entries = data.entries ?? [];
+    const sorted = [...entries].sort((a, b) => b.currentStreak - a.currentStreak);
+    sorted.forEach((e, i) => {
+      e.rank = i + 1;
+      e.isYou = e.userId === profile.id;
+    });
+    return {
+      entries: sorted,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: sync.endpoint,
+      weekStart: data.weekStart ?? ""
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/ui/renderer.ts
+init_date_utils();
+init_milestone_checker();
+import chalk3 from "chalk";
+import boxen from "boxen";
+import dayjs2 from "dayjs";
+import utc2 from "dayjs/plugin/utc.js";
+import timezone2 from "dayjs/plugin/timezone.js";
+dayjs2.extend(utc2);
+dayjs2.extend(timezone2);
+function flameBar(current, next) {
+  if (next <= current) return "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2713";
+  const pct = Math.min(current / next, 1);
+  const filled = Math.round(pct * 12);
+  const empty = 12 - filled;
+  return chalk3.red("\u2588".repeat(filled)) + chalk3.gray("\u2591".repeat(empty)) + chalk3.dim(` \u2192 day ${next}`);
+}
+function weekCalendar(activity, tz) {
+  const days = ["M", "T", "W", "T", "F", "S", "S"];
+  const today = dayjs2().tz ? dayjs2().tz(tz) : dayjs2();
+  const dayOfWeek = today.day();
+  const mondayOffset = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
+  const activityDates = new Set(activity.map((a) => a.date));
+  const row = days.map((label, i) => {
+    const d = today.add(mondayOffset + i, "day");
+    const dateStr = d.format("YYYY-MM-DD");
+    const isToday = dateStr === today.format("YYYY-MM-DD");
+    const isFuture = d.isAfter(today, "day");
+    const hasActivity = activityDates.has(dateStr);
+    let cell;
+    if (isFuture) cell = chalk3.gray("\xB7");
+    else if (hasActivity) cell = chalk3.green("\u2713");
+    else cell = chalk3.red("\u2717");
+    return isToday ? chalk3.bold.underline(`${label}:${cell}`) : `${label}:${cell}`;
+  });
+  return row.join("  ");
+}
+function nextMilestone(currentStreak) {
+  const milestones = getAllMilestones();
+  const next = milestones.find((m) => m.streakRequired > currentStreak);
+  if (!next) return null;
+  return { days: next.streakRequired, daysAway: next.streakRequired - currentStreak };
+}
+function renderStatus(profile, streak, activity, { quiet = false, json = false } = {}) {
+  if (json) {
+    return JSON.stringify({ streak, profile: { username: profile.username, timezone: profile.timezone } }, null, 2);
+  }
+  const today = todayInTz(profile.timezone);
+  const secsLeft = secondsUntilMidnight(profile.timezone);
+  const isProtected = streak.lastActivityDate === today;
+  const isExpired = streak.status === "broken" && streak._expiredStreak !== void 0;
+  const streakEmoji = isExpired ? "\u{1F331}" : streak.currentStreak >= 100 ? "\u{1F4AF}" : streak.currentStreak >= 30 ? "\u{1F3C6}" : "\u{1F525}";
+  const statusLabel = isExpired ? chalk3.dim(`Last streak: ${streak._expiredStreak}d \u2014 run ${chalk3.white("vibechk")} to start fresh`) : isProtected ? chalk3.green("\u2713 Protected for today") : secsLeft < 3600 ? chalk3.red(`\u26A0 ${formatCountdown(secsLeft)} left to check in!`) : chalk3.yellow(`\u25CB Check in before midnight`);
+  const next = nextMilestone(streak.currentStreak);
+  const progressBar = next ? flameBar(streak.currentStreak, next.days) : chalk3.green("\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588 All milestones reached!");
+  const freezeDisplay = "\u2744".repeat(streak.freezeTokens) + (streak.freezeTokens === 0 ? chalk3.gray("none") : "");
+  const recentWeek = activity.filter((a) => {
+    const diff = dayjs2(today).diff(dayjs2(a.date), "day");
+    return diff >= 0 && diff < 7;
+  });
+  const thirtyDaysAgo = dayjs2(today).subtract(29, "day").format("YYYY-MM-DD");
+  const activeLast30 = activity.filter((a) => a.date >= thirtyDaysAgo && a.date <= today).length;
+  const consistencyPct = Math.round(activeLast30 / 30 * 100);
+  const consistencyColor = consistencyPct >= 80 ? chalk3.green : consistencyPct >= 50 ? chalk3.yellow : chalk3.red;
+  const consistencyLabel = consistencyColor(`${consistencyPct}%`) + chalk3.dim(` (${activeLast30}/30 days)`);
+  if (quiet) {
+    return `${streak.currentStreak}d streak`;
+  }
+  const lines = [
+    `${streakEmoji} ${chalk3.bold.yellow(streak.currentStreak + "-day streak")}  ${statusLabel}`,
+    ``,
+    `Progress     ${progressBar}`,
+    `Longest      ${chalk3.cyan(streak.longestStreak + "d")}  \u2502  Freezes ${freezeDisplay}`,
+    `Consistency  ${consistencyLabel}`,
+    ``,
+    weekCalendar(recentWeek, profile.timezone),
+    ``,
+    chalk3.dim(`${friendlyDate(today)}  \u2502  ${profile.username}`)
+  ];
+  return boxen(lines.join("\n"), {
+    padding: { top: 0, bottom: 0, left: 1, right: 1 },
+    borderStyle: "round",
+    borderColor: isExpired ? "gray" : isProtected ? "green" : streak.currentStreak > 0 ? "yellow" : "gray",
+    title: " vibechk ",
+    titleAlignment: "center"
+  });
+}
+function renderCheckIn(action, streak, previousStreak, newMilestones = [], quiet = false) {
+  if (quiet) return "";
+  const lines = [];
+  if (action === "already_checked_in") {
+    lines.push(chalk3.green(`\u2713 Already checked in today \u2014 ${streak}-day streak protected.`));
+    return lines.join("\n");
+  }
+  if (action === "broken") {
+    if (previousStreak && previousStreak > 0) {
+      lines.push(chalk3.cyan(`Your ${previousStreak}-day streak was real.`));
+      lines.push(chalk3.dim(`  Every day you showed up counted. That doesn't disappear.`));
+      lines.push(``);
+    }
+    lines.push(chalk3.yellow(`\u{1F331} Day 1. Fresh start.`));
+    return boxen(lines.join("\n"), { padding: 1, borderColor: "cyan", borderStyle: "round" });
+  }
+  const actionEmoji = action === "started" ? "\u{1F331}" : action === "grace" ? "\u2728" : action === "frozen" ? "\u2744\uFE0F" : "\u{1F525}";
+  const actionLabel = action === "started" ? "Day 1! The journey begins." : action === "grace" ? `Grace period used \u2014 streak preserved!` : action === "frozen" ? `Freeze token used \u2014 streak preserved!` : `Day ${streak}! Streak protected.`;
+  lines.push(`${actionEmoji} ${chalk3.bold(actionLabel)}`);
+  lines.push(chalk3.dim(`\u{1F525} ${streak}-day streak`));
+  return lines.join("\n");
+}
+function renderMilestone(milestone, streak) {
+  const border = milestone.rarity === "legendary" ? "double" : milestone.rarity === "epic" ? "bold" : "round";
+  const color = milestone.rarity === "legendary" ? "magentaBright" : milestone.rarity === "epic" ? "yellowBright" : "cyan";
+  const lines = [
+    chalk3.bold.yellow("\u2B50 ACHIEVEMENT UNLOCKED!"),
+    ``,
+    `${milestone.icon}  ${chalk3.bold(milestone.name)}`,
+    chalk3.dim(milestone.description),
+    ``,
+    chalk3.green(`${streak}-day streak reached!`)
+  ];
+  if (milestone.freezeTokenReward > 0) {
+    lines.push(``);
+    lines.push(chalk3.cyan(`+ ${milestone.freezeTokenReward} freeze token earned!`));
+  }
+  return boxen(lines.join("\n"), {
+    padding: 1,
+    borderStyle: border,
+    borderColor: color,
+    title: ` ${milestone.rarity.toUpperCase()} `,
+    titleAlignment: "center"
+  });
+}
+
+// src/web/server.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+import { createServer } from "http";
+
+// src/storage/leaderboard-cache.ts
+init_atomic();
+init_paths();
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+function loadLeaderboardCache() {
+  return readJson(LEADERBOARD_CACHE_PATH);
+}
+function saveLeaderboardCache(cache) {
+  ensureDir();
+  writeJson(LEADERBOARD_CACHE_PATH, cache);
+}
+function isCacheStale(cache) {
+  const age = Date.now() - new Date(cache.fetchedAt).getTime();
+  return age > CACHE_TTL_MS;
+}
+
+// src/web/server.ts
+init_milestone_checker();
+init_date_utils();
+async function startDashboard(autoClose = true) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const leaderboard = loadLeaderboardCache();
+  const milestones = getAllMilestones();
+  const today = todayInTz(profile.timezone);
+  const dashboardData = {
+    profile: { username: profile.username, timezone: profile.timezone },
+    streak,
+    recentActivity: activity.slice(-90),
+    badges: badges.earned,
+    milestones,
+    leaderboard,
+    today
+  };
+  const html = generateDashboardHtml(dashboardData);
+  const server = createServer((req, res) => {
+    if (req.url === "/data") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(dashboardData));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+    if (autoClose) {
+      setTimeout(() => server.close(), 500);
+    }
+  });
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const url = `http://127.0.0.1:${addr.port}`;
+      resolve(url);
+    });
+  });
+}
+function generateDashboardHtml(data) {
+  const { profile, streak, recentActivity, badges, milestones, leaderboard, today } = data;
+  const activityMap = {};
+  for (const a of recentActivity) {
+    activityMap[a.date] = { checked: true, frozen: a.isFrozen, grace: a.isGrace, source: a.source };
+  }
+  const cells = [];
+  for (let i = 89; i >= 0; i--) {
+    const d = /* @__PURE__ */ new Date();
+    d.setDate(d.getDate() - i);
+    const dateStr = d.toISOString().slice(0, 10);
+    const act = activityMap[dateStr];
+    const isToday = dateStr === today;
+    let cls = "day-empty";
+    if (act?.frozen) cls = "day-frozen";
+    else if (act?.grace) cls = "day-grace";
+    else if (act?.checked) cls = "day-active";
+    if (isToday) cls += " day-today";
+    cells.push(`<div class="day ${cls}" title="${dateStr}"></div>`);
+  }
+  const lbRows = leaderboard ? leaderboard.entries.slice(0, 20).map((e) => {
+    const isYou = e.userId === profile.id || e.displayName === profile.username;
+    const badges_icons = (e.badges || []).slice(0, 3).map((id) => milestones.find((m) => m.id === id)?.icon ?? "").join("");
+    return `<tr class="${isYou ? "you" : ""}">
+          <td class="rank">${e.rank ?? "?"}</td>
+          <td class="name">${isYou ? "\u2192 " : ""}${e.displayName}</td>
+          <td class="streak">${e.currentStreak}d</td>
+          <td class="longest">${e.longestStreak}d</td>
+          <td class="badges">${badges_icons}${e.freezesUsed > 0 ? `<span class="freeze-used">${e.freezesUsed}\u2744</span>` : ""}</td>
+        </tr>`;
+  }).join("\n") : '<tr><td colspan="5" class="empty">No leaderboard data \u2014 run <code>vibechk sync</code></td></tr>';
+  const earnedIds = new Set(badges.map((b) => b.milestoneId));
+  const milestoneCards = milestones.map((m) => {
+    const earned = earnedIds.has(m.id);
+    return `<div class="milestone-card ${earned ? "earned" : "locked"} rarity-${m.rarity}">
+      <div class="ms-icon">${earned ? m.icon : "\u{1F512}"}</div>
+      <div class="ms-name">${m.name}</div>
+      <div class="ms-req">${m.streakRequired}d</div>
+    </div>`;
+  }).join("\n");
+  const isCheckedInToday = streak.lastActivityDate === today;
+  const streakEmoji = streak.currentStreak >= 100 ? "\u{1F4AF}" : streak.currentStreak >= 30 ? "\u{1F3C6}" : "\u{1F525}";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>vibechk \u2014 ${profile.username}</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --surface: #161b22;
+      --border: #30363d;
+      --text: #e6edf3;
+      --muted: #8b949e;
+      --accent: #f78166;
+      --green: #3fb950;
+      --yellow: #d29922;
+      --blue: #58a6ff;
+      --frozen: #79c0ff;
+      --grace: #ffa657;
+      --purple: #bc8cff;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      min-height: 100vh;
+      padding: 24px;
+    }
+    h1, h2, h3 { font-weight: 600; }
+    .container { max-width: 900px; margin: 0 auto; }
+    header {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      margin-bottom: 32px;
+    }
+    header .logo {
+      font-size: 1.5rem;
+      font-weight: 700;
+      background: linear-gradient(135deg, #f78166, #d29922);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+    header .username {
+      color: var(--muted);
+      font-size: 0.9rem;
+    }
+
+    /* Streak hero card */
+    .streak-hero {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 28px 32px;
+      margin-bottom: 24px;
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 16px;
+      align-items: center;
+    }
+    .streak-number {
+      font-size: 4rem;
+      font-weight: 700;
+      line-height: 1;
+      color: var(--accent);
+    }
+    .streak-label {
+      color: var(--muted);
+      font-size: 0.9rem;
+      margin-top: 4px;
+    }
+    .streak-stats {
+      display: flex;
+      gap: 24px;
+    }
+    .stat { text-align: center; }
+    .stat-value { font-size: 1.5rem; font-weight: 600; color: var(--blue); }
+    .stat-label { font-size: 0.75rem; color: var(--muted); margin-top: 2px; }
+
+    .status-badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 12px;
+      border-radius: 20px;
+      font-size: 0.8rem;
+      font-weight: 500;
+      margin-top: 8px;
+    }
+    .status-badge.protected { background: rgba(63, 185, 80, 0.15); color: var(--green); border: 1px solid rgba(63,185,80,0.3); }
+    .status-badge.at-risk { background: rgba(210, 153, 34, 0.15); color: var(--yellow); border: 1px solid rgba(210,153,34,0.3); }
+    .status-badge.broken { background: rgba(247, 129, 102, 0.15); color: var(--accent); border: 1px solid rgba(247,129,102,0.3); }
+
+    .freeze-tokens {
+      font-size: 1.2rem;
+      margin-top: 8px;
+    }
+
+    /* Progress bar */
+    .progress-section {
+      margin-top: 16px;
+      grid-column: 1 / -1;
+    }
+    .progress-label {
+      font-size: 0.75rem;
+      color: var(--muted);
+      margin-bottom: 6px;
+    }
+    .progress-bar-track {
+      height: 8px;
+      background: var(--border);
+      border-radius: 4px;
+      overflow: hidden;
+    }
+    .progress-bar-fill {
+      height: 100%;
+      border-radius: 4px;
+      background: linear-gradient(90deg, #f78166, #d29922);
+      transition: width 0.6s ease;
+    }
+
+    /* Calendar grid */
+    .section {
+      background: var(--surface);
+      border: 1px solid var(--border);
+      border-radius: 12px;
+      padding: 20px 24px;
+      margin-bottom: 24px;
+    }
+    .section h2 {
+      font-size: 0.85rem;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: var(--muted);
+      margin-bottom: 16px;
+    }
+    .calendar-grid {
+      display: grid;
+      grid-template-columns: repeat(13, 1fr);
+      gap: 3px;
+    }
+    .day {
+      aspect-ratio: 1;
+      border-radius: 3px;
+      cursor: default;
+      transition: transform 0.1s;
+    }
+    .day:hover { transform: scale(1.3); }
+    .day-empty { background: var(--border); }
+    .day-active { background: var(--green); }
+    .day-frozen { background: var(--frozen); }
+    .day-grace { background: var(--grace); }
+    .day-today { outline: 2px solid var(--text); outline-offset: 1px; }
+    .calendar-legend {
+      display: flex;
+      gap: 16px;
+      margin-top: 12px;
+      flex-wrap: wrap;
+    }
+    .legend-item {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 0.75rem;
+      color: var(--muted);
+    }
+    .legend-dot {
+      width: 12px;
+      height: 12px;
+      border-radius: 3px;
+    }
+
+    /* Leaderboard */
+    table { width: 100%; border-collapse: collapse; }
+    th, td { padding: 8px 12px; text-align: left; font-size: 0.875rem; }
+    th { color: var(--muted); font-weight: 500; border-bottom: 1px solid var(--border); }
+    tr.you { background: rgba(88, 166, 255, 0.08); }
+    tr.you td { color: var(--blue); font-weight: 600; }
+    td.rank { color: var(--muted); width: 40px; }
+    td.streak { color: var(--accent); font-weight: 600; }
+    td.longest { color: var(--muted); }
+    td.badges { font-size: 1rem; letter-spacing: 2px; }
+    td.empty { color: var(--muted); font-style: italic; padding: 20px 12px; }
+    .freeze-used { font-size: 0.7rem; color: var(--frozen); margin-left: 4px; }
+    tr:hover:not(.you) { background: rgba(255,255,255,0.03); }
+
+    /* Milestones */
+    .milestones-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
+      gap: 12px;
+    }
+    .milestone-card {
+      text-align: center;
+      padding: 16px 8px;
+      border-radius: 10px;
+      border: 1px solid var(--border);
+      transition: transform 0.2s;
+    }
+    .milestone-card:hover { transform: translateY(-2px); }
+    .milestone-card.locked { opacity: 0.35; filter: grayscale(1); }
+    .milestone-card.earned { border-color: transparent; }
+    .milestone-card.rarity-common.earned { background: rgba(63,185,80,0.1); border-color: rgba(63,185,80,0.3); }
+    .milestone-card.rarity-rare.earned { background: rgba(88,166,255,0.1); border-color: rgba(88,166,255,0.3); }
+    .milestone-card.rarity-epic.earned { background: rgba(210,153,34,0.1); border-color: rgba(210,153,34,0.3); }
+    .milestone-card.rarity-legendary.earned { background: rgba(188,140,255,0.1); border-color: rgba(188,140,255,0.3); }
+    .ms-icon { font-size: 1.75rem; margin-bottom: 6px; }
+    .ms-name { font-size: 0.7rem; font-weight: 600; color: var(--text); }
+    .ms-req { font-size: 0.65rem; color: var(--muted); margin-top: 2px; }
+
+    /* Animations */
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.7; } }
+    .streak-number { animation: ${isCheckedInToday ? "none" : "pulse 2s ease-in-out infinite"}; }
+
+    @keyframes celebrate {
+      0% { transform: scale(1); }
+      50% { transform: scale(1.05); }
+      100% { transform: scale(1); }
+    }
+    .celebrate { animation: celebrate 0.5s ease-in-out; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <div class="logo">vibechk</div>
+      <div class="username">@${profile.username}</div>
+    </header>
+
+    <!-- Streak Hero -->
+    <div class="streak-hero" id="heroCard">
+      <div>
+        <div class="streak-number">${streakEmoji} ${streak.currentStreak}</div>
+        <div class="streak-label">day streak</div>
+        <div class="status-badge ${isCheckedInToday ? "protected" : streak.currentStreak > 0 ? "at-risk" : "broken"}">
+          ${isCheckedInToday ? "\u2713 Protected for today" : streak.currentStreak > 0 ? "\u25CB Check in to protect" : "\u25CF Start your streak"}
+        </div>
+        <div class="freeze-tokens" title="Freeze tokens available">
+          ${"\u2744\uFE0F".repeat(streak.freezeTokens)}${streak.freezeTokens === 0 ? '<span style="color:var(--muted);font-size:0.8rem">No freezes</span>' : ""}
+        </div>
+      </div>
+      <div class="streak-stats">
+        <div class="stat">
+          <div class="stat-value">${streak.longestStreak}d</div>
+          <div class="stat-label">Longest</div>
+        </div>
+        <div class="stat">
+          <div class="stat-value">${streak.totalCheckIns}</div>
+          <div class="stat-label">Total days</div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Activity Calendar -->
+    <div class="section">
+      <h2>Last 90 Days</h2>
+      <div class="calendar-grid">
+        ${cells.join("\n        ")}
+      </div>
+      <div class="calendar-legend">
+        <div class="legend-item"><div class="legend-dot" style="background:var(--green)"></div> Coded</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--frozen)"></div> Frozen</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--grace)"></div> Grace</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--border)"></div> Missed</div>
+      </div>
+    </div>
+
+    <!-- Leaderboard -->
+    <div class="section">
+      <h2>Leaderboard</h2>
+      ${leaderboard ? `<table>
+        <thead>
+          <tr>
+            <th>Rank</th>
+            <th>Name</th>
+            <th>Streak</th>
+            <th>Longest</th>
+            <th>Badges</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${lbRows}
+        </tbody>
+      </table>` : '<p style="color:var(--muted);font-size:0.875rem">No leaderboard data yet. Configure cloud sync to compare with friends.</p>'}
+    </div>
+
+    <!-- Milestones -->
+    <div class="section">
+      <h2>Milestones</h2>
+      <div class="milestones-grid">
+        ${milestoneCards}
+      </div>
+    </div>
+  </div>
+
+  <script>
+    // Celebrate if just reached a new milestone
+    const urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.get('celebrate')) {
+      document.getElementById('heroCard').classList.add('celebrate');
+    }
+
+    // Auto-refresh every 60s
+    setTimeout(() => window.location.reload(), 60000);
+  </script>
+</body>
+</html>`;
+}
+
+// src/commands/check-in.ts
+import openBrowser from "open";
+async function runCheckIn(options = {}) {
+  const profile = requireProfile();
+  const today = todayInTz(profile.timezone);
+  const now = nowIso();
+  let source = options.source ?? "manual";
+  let agentData = void 0;
+  if (!options.source || options.source === "claude-code") {
+    const spinner = ora({ text: "Detecting coding session\u2026", isSilent: options.quiet }).start();
+    const detection = await detectTodaySession(
+      today,
+      profile.timezone,
+      profile.preferences.sessionSources,
+      profile.preferences.watchedRepos ?? []
+    );
+    spinner.stop();
+    if (detection.detected) {
+      source = detection.source;
+      agentData = detection.agentData;
+    } else if (options.noInteractive) {
+      if (!options.quiet) {
+        console.log(chalk6.dim("  No coding session detected today. Streak unchanged."));
+      }
+      const currentStreak2 = loadStreak();
+      return {
+        action: "skipped",
+        streak: currentStreak2.currentStreak,
+        previousStreak: void 0,
+        newMilestones: [],
+        freezeTokensRemaining: currentStreak2.freezeTokens,
+        agentData: void 0
+      };
+    } else if (!options.quiet) {
+      const doManual = await confirm2({
+        message: chalk6.dim("No AI session detected. Check in manually anyway?"),
+        default: true
+      });
+      if (!doManual) {
+        console.log(chalk6.dim("  Skipped. Run vibechk again when you've coded today."));
+        process.exit(0);
+      }
+      source = "manual";
+    }
+  }
+  const currentStreak = loadStreak();
+  const currentBadges = loadBadges();
+  let useFreeze = options.autoFreeze ?? false;
+  const impact = calculateStreakImpact(currentStreak, today, false);
+  if (impact.action === "broken" && impact.previousStreak && impact.previousStreak > 0 && currentStreak.freezeTokens > 0 && !options.noInteractive && !options.quiet) {
+    const daysDiff = currentStreak.lastActivityDate ? Math.abs(new Date(today).getTime() - new Date(currentStreak.lastActivityDate).getTime()) / 864e5 : 99;
+    if (daysDiff <= 2) {
+      console.log(chalk6.yellow(`
+  Missed yesterday. You have ${currentStreak.freezeTokens} freeze token(s).`));
+      useFreeze = await confirm2({
+        message: `Use a freeze token to preserve your ${impact.previousStreak}-day streak?`,
+        default: true
+      });
+    }
+  }
+  const finalImpact = calculateStreakImpact(currentStreak, today, useFreeze);
+  const newStreakRecord = applyStreakImpact(currentStreak, finalImpact, today, now);
+  const newMilestones = checkNewMilestones(newStreakRecord.currentStreak, currentBadges);
+  const newBadges = createEarnedBadges(newMilestones, newStreakRecord.currentStreak, now);
+  const freezeReward = totalFreezeReward(newMilestones);
+  if (freezeReward > 0) {
+    newStreakRecord.freezeTokens = addFreezeTokens(newStreakRecord.freezeTokens, freezeReward);
+  }
+  if (!options.dryRun) {
+    saveStreak(newStreakRecord);
+    appendBadges(newBadges);
+    if (finalImpact.action !== "already_checked_in") {
+      appendActivity({
+        date: today,
+        checkedInAt: now,
+        source,
+        isFrozen: finalImpact.action === "frozen",
+        isGrace: finalImpact.action === "grace",
+        sessionId: uuidv42(),
+        agentData,
+        notes: options.notes
+      });
+    }
+  }
+  if (!options.quiet && !options.json) {
+    console.log("");
+    console.log(renderCheckIn(finalImpact.action, newStreakRecord.currentStreak, finalImpact.previousStreak, newMilestones));
+    for (const milestone of newMilestones) {
+      console.log("");
+      console.log(renderMilestone(milestone, newStreakRecord.currentStreak));
+    }
+    console.log("");
+  } else if (options.json) {
+    const result = {
+      action: finalImpact.action,
+      streak: newStreakRecord.currentStreak,
+      previousStreak: finalImpact.previousStreak,
+      newMilestones: newMilestones.map((m) => m.id),
+      freezeTokensRemaining: newStreakRecord.freezeTokens
+    };
+    console.log(JSON.stringify(result));
+  }
+  const shouldOpenBrowser = options.openDashboard || newMilestones.length > 0 && !options.quiet;
+  if (shouldOpenBrowser && !options.dryRun) {
+    try {
+      const url = await startDashboard(true);
+      const celebrateUrl = newMilestones.length > 0 ? `${url}?celebrate=1` : url;
+      await openBrowser(celebrateUrl);
+      if (!options.quiet) console.log(chalk6.dim(`  Opening dashboard in browser\u2026`));
+    } catch {
+    }
+  }
+  if (!options.dryRun && profile.cloudSync) {
+    const badges = loadBadges();
+    pushStreak(profile, newStreakRecord, badges).catch(() => {
+    });
+  }
+  if (!options.dryRun && options.noInteractive && finalImpact.action !== "already_checked_in") {
+    Promise.resolve().then(() => (init_publish(), publish_exports)).then(({ runPublish: runPublish2 }) => runPublish2({ silent: true })).catch(() => {
+    });
+    Promise.resolve().then(() => (init_friend(), friend_exports)).then(({ runFriendPull: runFriendPull2 }) => runFriendPull2({ quiet: true })).catch(() => {
+    });
+  }
+  return {
+    action: finalImpact.action,
+    streak: newStreakRecord.currentStreak,
+    previousStreak: finalImpact.previousStreak,
+    newMilestones,
+    freezeTokensRemaining: newStreakRecord.freezeTokens,
+    agentData
+  };
+}
+
+// src/commands/status.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_date_utils();
+import openBrowser2 from "open";
+import chalk7 from "chalk";
+async function runStatus(options = {}) {
+  const profile = requireProfile();
+  const stored = loadStreak();
+  const activity = loadActivity();
+  const today = todayInTz(profile.timezone);
+  const impact = calculateStreakImpact(stored, today, false);
+  const streak = impact.action === "broken" ? { ...stored, currentStreak: 0, status: "broken", _expiredStreak: stored.currentStreak } : stored;
+  if (options.web) {
+    const url = await startDashboard(false);
+    console.log(chalk7.dim(`  Opening dashboard at ${url}`));
+    await openBrowser2(url);
+    await new Promise((resolve) => setTimeout(resolve, 5 * 60 * 1e3));
+    process.exit(0);
+    return;
+  }
+  const output = renderStatus(profile, streak, activity, {
+    quiet: options.quiet,
+    json: options.json
+  });
+  console.log(output);
+}
+
+// src/commands/freeze.ts
+init_profile_store();
+init_streak_store();
+init_date_utils();
+import chalk8 from "chalk";
+import { confirm as confirm3 } from "@inquirer/prompts";
+async function runFreeze(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  if (streak.freezeTokens === 0) {
+    console.log(chalk8.yellow("  No freeze tokens available."));
+    console.log(chalk8.dim("  Earn tokens by reaching milestones (30, 60, 90 days)."));
+    return;
+  }
+  const today = todayInTz(profile.timezone);
+  console.log(`
+  Freeze tokens: ${"\u2744\uFE0F".repeat(streak.freezeTokens)} (${streak.freezeTokens} available)`);
+  console.log(chalk8.dim(`  Current streak: ${streak.currentStreak} days
+`));
+  if (options.tomorrow) {
+    if (!options.noInteractive) {
+      const ok = await confirm3({
+        message: `Use 1 freeze token to protect your streak tomorrow?`,
+        default: true
+      });
+      if (!ok) {
+        console.log(chalk8.dim("  Cancelled."));
+        return;
+      }
+    }
+    const updated = {
+      ...streak,
+      freezeTokens: streak.freezeTokens - 1,
+      status: "active"
+      // Store scheduled freeze date in a field
+    };
+    saveStreak(updated);
+    console.log(chalk8.green(`
+  \u2713 Freeze token used. Your streak is protected for tomorrow.`));
+    console.log(chalk8.dim(`  Tokens remaining: ${updated.freezeTokens}
+`));
+    return;
+  }
+  if (streak.lastActivityDate) {
+    const daysDiff = daysBetween(streak.lastActivityDate, today);
+    if (daysDiff === 2) {
+      if (!options.noInteractive) {
+        const ok = await confirm3({
+          message: `Use 1 freeze token to recover your ${streak.currentStreak}-day streak? (missed 1 day)`,
+          default: true
+        });
+        if (!ok) {
+          console.log(chalk8.dim("  Cancelled."));
+          return;
+        }
+      }
+      const updated = {
+        ...streak,
+        freezeTokens: streak.freezeTokens - 1,
+        lastActivityDate: today,
+        status: "frozen"
+      };
+      saveStreak(updated);
+      console.log(chalk8.green(`
+  \u2713 Freeze applied. ${streak.currentStreak}-day streak preserved.`));
+      console.log(chalk8.dim(`  Tokens remaining: ${updated.freezeTokens}
+`));
+      return;
+    }
+  }
+  console.log(chalk8.dim("  Use --tomorrow to pre-apply a freeze for tomorrow."));
+  console.log(chalk8.dim("  Freezes are auto-offered when you run `vibechk check-in` after missing a day.\n"));
+}
+
+// src/commands/leaderboard.ts
+init_profile_store();
+import chalk10 from "chalk";
+import ora2 from "ora";
+
+// src/ui/leaderboard-view.ts
+init_milestone_checker();
+import chalk9 from "chalk";
+import dayjs3 from "dayjs";
+function badgeIcons(badgeIds) {
+  const milestones = getAllMilestones();
+  return badgeIds.map((id) => milestones.find((m) => m.id === id)?.icon ?? "").filter(Boolean).slice(0, 4).join("");
+}
+function formatEntry(entry, today) {
+  const rankStr = entry.rank ? String(entry.rank).padStart(3) : "  ?";
+  const nameStr = (entry.displayName ?? "anonymous").padEnd(16).slice(0, 16);
+  const streakStr = `${entry.currentStreak}d`.padStart(6);
+  const longestStr = `${entry.longestStreak}d`.padStart(8);
+  const badges = badgeIcons(entry.badges ?? []).padEnd(6);
+  const freeze = entry.freezesUsed > 0 ? chalk9.dim(` (${entry.freezesUsed}\u2744)`) : "";
+  const activeToday = entry.lastActiveDate === today ? chalk9.green(" \u25CF") : "";
+  const line = `${rankStr}  ${nameStr} ${streakStr}   ${longestStr}   ${badges}${freeze}${activeToday}`;
+  if (entry.isYou) return chalk9.bold.cyan("\u2192 " + line);
+  return "  " + line;
+}
+function renderLeaderboard(cache, myUserId) {
+  const today = dayjs3().format("YYYY-MM-DD");
+  const updatedAgo = Math.round((Date.now() - new Date(cache.fetchedAt).getTime()) / 6e4);
+  const source = cache.source.replace(/^https?:\/\//, "");
+  const header = [
+    chalk9.bold("Leaderboard") + chalk9.dim(` (${source}) \u2014 updated ${updatedAgo}m ago`),
+    ``,
+    chalk9.dim(`  Rank  Name              Streak   Longest   Badges`),
+    chalk9.dim(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`)
+  ].join("\n");
+  const me = cache.entries.find((e) => e.userId === myUserId);
+  const myRank = me?.rank ?? Infinity;
+  const showSet = /* @__PURE__ */ new Set();
+  cache.entries.slice(0, 5).forEach((e) => showSet.add(e.rank ?? 0));
+  cache.entries.filter((e) => {
+    const r = e.rank ?? 0;
+    return r >= myRank - 5 && r <= myRank + 5;
+  }).forEach((e) => showSet.add(e.rank ?? 0));
+  const shown = cache.entries.filter((e) => showSet.has(e.rank ?? 0));
+  let lastRank = 0;
+  const rows = [];
+  for (const entry of shown) {
+    const rank = entry.rank ?? 0;
+    if (lastRank > 0 && rank > lastRank + 1) {
+      rows.push(chalk9.dim("  ..."));
+    }
+    rows.push(formatEntry(entry, today));
+    lastRank = rank;
+  }
+  if (rows.length === 0) {
+    rows.push(chalk9.dim("  No entries yet. Be the first!"));
+  }
+  return [header, ...rows, ""].join("\n");
+}
+
+// src/commands/leaderboard.ts
+import openBrowser3 from "open";
+async function runLeaderboard(options = {}) {
+  const profile = requireProfile();
+  if (options.web) {
+    const url = await startDashboard(false);
+    console.log(chalk10.dim(`  Opening leaderboard in browser at ${url}`));
+    await openBrowser3(url + "#leaderboard");
+    await new Promise((resolve) => setTimeout(resolve, 5 * 60 * 1e3));
+    process.exit(0);
+    return;
+  }
+  if (!profile.cloudSync) {
+    console.log("");
+    console.log(chalk10.yellow("  No cloud sync configured."));
+    console.log(chalk10.dim("  Run `vibechk init` and provide a leaderboard endpoint to compare with friends."));
+    console.log(chalk10.dim("  Or run `vibechk leaderboard --web` to see your local stats.\n"));
+    return;
+  }
+  let cache = loadLeaderboardCache();
+  if (!cache || options.refresh || isCacheStale(cache)) {
+    const spinner = ora2("Fetching leaderboard\u2026").start();
+    const fresh = await fetchLeaderboard(profile);
+    spinner.stop();
+    if (!fresh) {
+      console.log(chalk10.red("  Could not reach leaderboard server."));
+      if (cache) {
+        console.log(chalk10.dim("  Showing cached data.\n"));
+      } else {
+        return;
+      }
+    } else {
+      cache = fresh;
+      saveLeaderboardCache(cache);
+    }
+  }
+  if (!cache) return;
+  if (options.hideMe) {
+    cache = {
+      ...cache,
+      entries: cache.entries.map((e) => ({
+        ...e,
+        isYou: false
+      }))
+    };
+  }
+  console.log("");
+  console.log(renderLeaderboard(cache, profile.id));
+}
+
+// src/commands/export.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+async function runExport(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const data = {
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: "0.1.0",
+    profile: {
+      username: profile.username,
+      timezone: profile.timezone,
+      createdAt: profile.createdAt
+    },
+    streak,
+    activity,
+    badges
+  };
+  if (options.format === "csv") {
+    const rows = ["date,source,isFrozen,isGrace"];
+    for (const a of activity) {
+      rows.push(`${a.date},${a.source},${a.isFrozen},${a.isGrace}`);
+    }
+    process.stdout.write(rows.join("\n") + "\n");
+  } else {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  }
+}
+
+// src/commands/sync.ts
+init_profile_store();
+init_streak_store();
+init_badge_store();
+import chalk11 from "chalk";
+import ora3 from "ora";
+async function runSync() {
+  const profile = requireProfile();
+  if (!profile.cloudSync) {
+    console.log(chalk11.yellow("\n  No cloud sync configured."));
+    console.log(chalk11.dim("  Run `vibechk init` to set up a leaderboard endpoint.\n"));
+    return;
+  }
+  const streak = loadStreak();
+  const badges = loadBadges();
+  const spinner = ora3("Syncing to leaderboard\u2026").start();
+  const ok = await pushStreak(profile, streak, badges);
+  spinner.stop();
+  if (ok) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    profile.cloudSync.lastSyncedAt = now;
+    saveProfile(profile);
+    console.log(chalk11.green(`
+  \u2713 Synced to ${profile.cloudSync.endpoint}
+`));
+  } else {
+    console.log(chalk11.red(`
+  \u2717 Sync failed. Check your endpoint and API key.
+`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/log.ts
+init_profile_store();
+init_activity_store();
+init_date_utils();
+import chalk12 from "chalk";
+import dayjs4 from "dayjs";
+function runLog() {
+  const profile = requireProfile();
+  const activity = loadActivity();
+  const today = todayInTz(profile.timezone);
+  const activitySet = new Set(activity.map((a) => a.date));
+  const days = [];
+  for (let i = 29; i >= 0; i--) {
+    const d = dayjs4(today).subtract(i, "day");
+    const dateStr = d.format("YYYY-MM-DD");
+    days.push({
+      date: dateStr,
+      label: d.format("MMM D"),
+      active: activitySet.has(dateStr),
+      isToday: dateStr === today
+    });
+  }
+  const activeDays = days.filter((d) => d.active).length;
+  const consistencyPct = Math.round(activeDays / 30 * 100);
+  const startLabel = days[0].label;
+  const endLabel = days[days.length - 1].label;
+  console.log("");
+  console.log(chalk12.bold(`Last 30 days`) + chalk12.dim(`  ${startLabel} \u2013 ${endLabel}`));
+  console.log(chalk12.dim("  \u2713 coded  \xB7 missed"));
+  console.log("");
+  const WEEK_SIZE = 7;
+  const DAYS_SHORT = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+  const firstDayOfWeek = dayjs4(days[0].date).day();
+  const mondayAligned = firstDayOfWeek === 0 ? 6 : firstDayOfWeek - 1;
+  const headerOffset = " ".repeat(8 + mondayAligned * 3);
+  console.log(chalk12.dim(headerOffset + DAYS_SHORT.join(" ")));
+  for (let i = 0; i < days.length; i += WEEK_SIZE) {
+    const week = days.slice(i, i + WEEK_SIZE);
+    const rowLabel = chalk12.dim(week[0].label.padStart(6));
+    let prefix = "";
+    if (i === 0 && mondayAligned > 0) {
+      prefix = "   ".repeat(mondayAligned);
+    }
+    const cells = week.map((d) => {
+      let cell;
+      if (d.active) {
+        cell = chalk12.green("\u2713");
+      } else if (d.isToday) {
+        cell = chalk12.yellow("\u25CB");
+      } else {
+        cell = chalk12.dim("\xB7");
+      }
+      return d.isToday ? chalk12.underline(cell) : cell;
+    });
+    console.log(`  ${rowLabel}  ${prefix}${cells.join("  ")}`);
+  }
+  console.log("");
+  const consistencyColor = consistencyPct >= 80 ? chalk12.green : consistencyPct >= 50 ? chalk12.yellow : chalk12.red;
+  console.log(
+    `  Consistency: ` + consistencyColor(`${consistencyPct}%`) + chalk12.dim(` \u2014 ${activeDays} of 30 days`)
+  );
+  console.log("");
+}
+
+// src/commands/share.ts
+init_profile_store();
+init_streak_store();
+init_activity_store();
+init_badge_store();
+init_milestone_checker();
+init_date_utils();
+import chalk13 from "chalk";
+import { execSync as execSync4 } from "child_process";
+function runShare(options = {}) {
+  const profile = requireProfile();
+  const streak = loadStreak();
+  const activity = loadActivity();
+  const badges = loadBadges();
+  const today = todayInTz(profile.timezone);
+  const thirtyDaysAgo = /* @__PURE__ */ new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 29);
+  const cutoffStr = thirtyDaysAgo.toISOString().slice(0, 10);
+  const activeLast30 = activity.filter((a) => a.date >= cutoffStr && a.date <= today).length;
+  const consistencyPct = Math.round(activeLast30 / 30 * 100);
+  const allMilestones = getAllMilestones();
+  const earnedBadgeNames = badges.earned.map((b) => allMilestones.find((m) => m.id === b.milestoneId)).filter(Boolean).map((m) => `${m.icon} ${m.name}`);
+  if (options.json) {
+    console.log(JSON.stringify({
+      currentStreak: streak.currentStreak,
+      longestStreak: streak.longestStreak,
+      consistencyPct,
+      activeLast30,
+      badges: earnedBadgeNames
+    }, null, 2));
+    return;
+  }
+  const streakLine = streak.currentStreak >= 30 ? `\u{1F3C6} ${streak.currentStreak}-day vibe coding streak!` : `\u{1F525} ${streak.currentStreak}-day vibe coding streak`;
+  const statsLine = `\u{1F4CA} Best: ${streak.longestStreak}d  |  30-day consistency: ${consistencyPct}%`;
+  const badgeLine = earnedBadgeNames.length > 0 ? `\u{1F396}  ${earnedBadgeNames.slice(-3).join("  ")}` : null;
+  const ctaLine = `Built with vibechk \u2014 npm i -g vibechk`;
+  const shareLines = [streakLine, statsLine, badgeLine, ctaLine].filter(Boolean);
+  const shareText = shareLines.join("\n");
+  console.log("");
+  console.log(chalk13.bold("  Copy and share:"));
+  console.log("");
+  console.log(chalk13.dim("  \u250C" + "\u2500".repeat(Math.max(...shareLines.map((l) => l.length)) + 2) + "\u2510"));
+  for (const line of shareLines) {
+    console.log(chalk13.dim("  \u2502 ") + line + chalk13.dim(" \u2502"));
+  }
+  console.log(chalk13.dim("  \u2514" + "\u2500".repeat(Math.max(...shareLines.map((l) => l.length)) + 2) + "\u2518"));
+  console.log("");
+  tryCopyToClipboard(shareText);
+}
+function tryCopyToClipboard(text) {
+  const escaped = JSON.stringify(text);
+  const cmds = [
+    `echo ${escaped} | pbcopy`,
+    // macOS
+    `echo ${escaped} | xclip -selection clipboard`,
+    // Linux xclip
+    `echo ${escaped} | xsel --clipboard --input`
+    // Linux xsel
+  ];
+  for (const cmd of cmds) {
+    try {
+      execSync4(cmd, { stdio: "pipe" });
+      console.log(chalk13.dim("  Copied to clipboard \u2713"));
+      return;
+    } catch {
+    }
+  }
+}
+
+// src/cli.ts
+init_friend();
+init_publish();
+var program = new Command();
+program.name("vibechk").description("Daily streak tracker for vibe coders").version("0.1.0");
+program.action(async () => {
+  if (!dataExists()) {
+    console.log(chalk14.dim("  No profile found. Running setup...\n"));
+    await runInit();
+    return;
+  }
+  await runStatus({ quiet: false });
+});
+program.command("init").description("Set up your vibechk profile").action(async () => {
+  await runInit();
+});
+program.command("check-in").alias("checkin").alias("ci").description("Record a vibe coding session (auto-detects Claude Code usage)").option("-m, --manual", "Skip auto-detection, check in manually").option("--note <text>", "Add a note to this session").option("--auto-freeze", "Automatically use a freeze token if needed").option("--dry-run", "Compute but do not save").option("-q, --quiet", "Minimal output").option("--json", "Output as JSON").option("--no-interactive", "Non-interactive mode (no prompts)").option("--web", "Open browser dashboard after check-in").action(async (opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runCheckIn({
+    source: opts.manual ? "manual" : void 0,
+    notes: opts.note,
+    autoFreeze: opts.autoFreeze,
+    dryRun: opts.dryRun,
+    quiet: opts.quiet,
+    json: opts.json,
+    noInteractive: opts.noInteractive === false ? true : void 0,
+    openDashboard: opts.web
+  });
+});
+program.command("status").alias("s").description("Show your current streak and activity").option("-q, --quiet", "Single-line output").option("--json", "Output as JSON").option("--web", "Open browser dashboard").action(async (opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runStatus({ quiet: opts.quiet, json: opts.json, web: opts.web });
+});
+program.command("freeze").description("Manage freeze tokens (protect your streak against a missed day)").option("--tomorrow", "Pre-apply a freeze for tomorrow (planned absence)").option("--no-interactive", "Non-interactive mode").action(async (opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runFreeze({
+    tomorrow: opts.tomorrow,
+    noInteractive: opts.noInteractive === false ? true : void 0
+  });
+});
+program.command("leaderboard").alias("lb").description("View the opt-in community streak leaderboard").option("--refresh", "Force refresh (ignore 1hr cache)").option("--hide-me", "Hide yourself from display").option("--web", "Open in browser").action(async (opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runLeaderboard({ refresh: opts.refresh, hideMe: opts.hideMe, web: opts.web });
+});
+program.command("sync").description("Push your streak data to the cloud leaderboard").action(async () => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runSync();
+});
+program.command("export").description("Export all your streak data").option("--format <type>", "Output format: json (default) or csv", "json").action(async (opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runExport({ format: opts.format });
+});
+program.command("dashboard").alias("dash").description("Open the visual dashboard in your browser").action(async () => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  await runStatus({ web: true });
+});
+program.command("log").alias("l").description("Show your last 30 days as a calendar with consistency %").action(() => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  runLog();
+});
+program.command("share").description("Generate shareable text about your current streak").option("--json", "Output as JSON").action((opts) => {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+  runShare({ json: opts.json });
+});
+program.command("schedule").description("Set up or manage the daily auto-check-in job (launchd on macOS, cron on Linux)").option("--time <HH:MM>", "Time to run daily check-in (24-hour format)", "21:00").option("--remove", "Remove the daily auto-check-in job").option("--status", "Show whether a schedule is installed").action(async (opts) => {
+  await runSchedule({ time: opts.time, remove: opts.remove, status: opts.status });
+});
+program.command("friends").description("Show your friends' streaks").action(async () => {
+  requireInit();
+  await runFriendList();
+});
+var friendCmd = program.command("friend").description("Manage friend subscriptions");
+friendCmd.command("add <alias> [url]").description("Follow a friend's streak (URL required unless a remote endpoint is configured)").action(async (alias, url) => {
+  requireInit();
+  await runFriendAdd(alias, url);
+});
+friendCmd.command("remove <alias>").description("Unsubscribe from a friend").action((alias) => {
+  requireInit();
+  runFriendRemove(alias);
+});
+friendCmd.command("pull").description("Refresh all friends' streak data now").option("-q, --quiet", "Suppress output").action(async (opts) => {
+  requireInit();
+  await runFriendPull({ quiet: opts.quiet });
+});
+friendCmd.command("list").description("List all friends and their streaks").action(async () => {
+  requireInit();
+  await runFriendList();
+});
+program.command("publish").description("Publish your streak so friends can subscribe").option("--gist", "Publish to a GitHub Gist (default when no endpoint is configured)").option("--endpoint <url>", "Publish to a remote server endpoint (saved for future use)").option("--stdout", "Print the JSON payload to stdout").option("--token <token>", "GitHub personal access token (gist scope)").action(async (opts) => {
+  requireInit();
+  await runPublish({ gist: opts.gist, endpoint: opts.endpoint, stdout: opts.stdout, token: opts.token });
+});
+function requireInit() {
+  if (!dataExists()) {
+    console.log(chalk14.yellow("  Run `vibechk init` first.\n"));
+    process.exit(1);
+  }
+}
+program.parseAsync(process.argv).catch((err) => {
+  console.error(chalk14.red("Error:"), err.message);
+  process.exit(1);
+});