@tokscale/cli 1.0.13 → 1.0.15

package/src/tui/components/StatsView.tsx

@@ -1,6 +1,7 @@
 import { For, Show, createMemo, createSignal } from "solid-js";
 import type { TUIData } from "../hooks/useData.js";
 import type { ColorPaletteName } from "../config/themes.js";
+import type { SortType, GridCell } from "../types/index.js";
 import { getPalette, getGradeColor } from "../config/themes.js";
 import { getModelColor } from "../utils/colors.js";
 import { formatTokens } from "../utils/format.js";
@@ -13,6 +14,7 @@ interface StatsViewProps {
   colorPalette: ColorPaletteName;
   width?: number;
   selectedDate?: string | null;
+  sortBy?: SortType;
 }
 
 const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
@@ -27,8 +29,30 @@ interface MonthLabel {
 export function StatsView(props: StatsViewProps) {
   const palette = () => getPalette(props.colorPalette);
   const isNarrowTerminal = () => isNarrow(props.width);
-  const grid = () => props.data.contributionGrid;
+  const metric = () => props.sortBy ?? "tokens";
   const cellWidth = 2;
+
+  const grid = createMemo((): GridCell[][] => {
+    const contributions = props.data.contributions;
+    const baseGrid = props.data.contributionGrid;
+    
+    const values = contributions.map(c => metric() === "tokens" ? c.tokens : c.cost);
+    const maxValue = Math.max(1, ...values);
+    
+    const levelMap = new Map<string, number>();
+    for (const c of contributions) {
+      const value = metric() === "tokens" ? c.tokens : c.cost;
+      const level = value === 0 ? 0 : Math.min(4, Math.ceil((value / maxValue) * 4));
+      levelMap.set(c.date, level);
+    }
+    
+    return baseGrid.map(row => 
+      row.map(cell => ({
+        date: cell.date,
+        level: cell.date ? (levelMap.get(cell.date) ?? 0) : 0,
+      }))
+    );
+  });
   
   const [clickedCell, setClickedCell] = createSignal<string | null>(null);
   

package/src/tui/config/settings.ts

@@ -9,9 +9,36 @@ const CONFIG_FILE = join(CONFIG_DIR, "tui-settings.json");
 const CACHE_FILE = join(CACHE_DIR, "tui-data-cache.json");
 
 const CACHE_STALE_THRESHOLD_MS = 60 * 1000;
+const MIN_AUTO_REFRESH_MS = 30000;
+const MAX_AUTO_REFRESH_MS = 3600000;
+const DEFAULT_AUTO_REFRESH_MS = 60000;
 
 interface TUISettings {
   colorPalette: string;
+  autoRefreshEnabled?: boolean;
+  autoRefreshMs?: number;
+}
+
+function validateSettings(raw: unknown): TUISettings {
+  const defaults: TUISettings = { 
+    colorPalette: "blue", 
+    autoRefreshEnabled: false, 
+    autoRefreshMs: DEFAULT_AUTO_REFRESH_MS 
+  };
+  
+  if (!raw || typeof raw !== "object") return defaults;
+  
+  const obj = raw as Record<string, unknown>;
+  
+  const colorPalette = typeof obj.colorPalette === "string" ? obj.colorPalette : defaults.colorPalette;
+  const autoRefreshEnabled = typeof obj.autoRefreshEnabled === "boolean" ? obj.autoRefreshEnabled : defaults.autoRefreshEnabled;
+  
+  let autoRefreshMs = defaults.autoRefreshMs;
+  if (typeof obj.autoRefreshMs === "number" && Number.isFinite(obj.autoRefreshMs)) {
+    autoRefreshMs = Math.min(MAX_AUTO_REFRESH_MS, Math.max(MIN_AUTO_REFRESH_MS, obj.autoRefreshMs));
+  }
+  
+  return { colorPalette, autoRefreshEnabled, autoRefreshMs };
 }
 
 interface CachedTUIData {
@@ -25,18 +52,24 @@ interface CachedTUIData {
 export function loadSettings(): TUISettings {
   try {
     if (existsSync(CONFIG_FILE)) {
-      return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      const raw = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+      return validateSettings(raw);
     }
   } catch {
   }
-  return { colorPalette: "green" };
+  return { colorPalette: "blue", autoRefreshEnabled: false, autoRefreshMs: DEFAULT_AUTO_REFRESH_MS };
 }
 
-export function saveSettings(settings: TUISettings): void {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
+export function saveSettings(updates: Partial<TUISettings>): void {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = loadSettings();
+    const merged = { ...current, ...updates };
+    writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  } catch {
   }
-  writeFileSync(CONFIG_FILE, JSON.stringify(settings, null, 2));
 }
 
 function sourcesMatch(enabledSources: Set<string>, cachedSources: string[]): boolean {

package/src/tui/hooks/useData.ts

@@ -245,9 +245,14 @@ async function loadData(enabledSources: Set<SourceType>, dateFilters?: DateFilte
   for (const d of dailyEntries) {
     if (d.cost > maxCost) maxCost = d.cost;
   }
+  let maxTokens = 1;
+  for (const d of dailyEntries) {
+    if (d.total > maxTokens) maxTokens = d.total;
+  }
   const contributions: ContributionDay[] = dailyEntries.map(d => ({
     date: d.date,
     cost: d.cost,
+    tokens: d.total,
     level: d.cost === 0 ? 0 : (Math.min(4, Math.ceil((d.cost / maxCost) * 4)) as 0 | 1 | 2 | 3 | 4),
   }));
 
@@ -452,13 +457,21 @@ export function useData(enabledSources: Accessor<Set<SourceType>>, dateFilters?:
   const [isRefreshing, setIsRefreshing] = createSignal(initialCachedData ? initialCacheIsStale : false);
 
   const [forceRefresh, setForceRefresh] = createSignal(false);
+  let pendingRefresh = false;
+  let currentRequestId = 0;
 
   const refresh = () => {
+    if (isRefreshing() || loading()) {
+      pendingRefresh = true;
+      return;
+    }
+    setIsRefreshing(true);
     setForceRefresh(true);
     setRefreshTrigger(prev => prev + 1);
   };
 
   const doLoad = (sources: Set<SourceType>, skipCacheCheck = false) => {
+    ++currentRequestId; // Invalidate any in-flight requests immediately
     const shouldSkipCache = skipCacheCheck || forceRefresh();
     
     if (!shouldSkipCache) {
@@ -488,17 +501,27 @@ export function useData(enabledSources: Accessor<Set<SourceType>>, dateFilters?:
       setForceRefresh(false);
     }
     
+    const requestId = currentRequestId;
     setError(null);
     loadData(sources, dateFilters)
       .then((freshData) => {
+        if (requestId !== currentRequestId) return;
         setData(freshData);
         saveCachedData(freshData, sources);
       })
-      .catch((e) => setError(e.message))
+      .catch((e: unknown) => {
+        if (requestId !== currentRequestId) return;
+        setError(e instanceof Error ? e.message : String(e));
+      })
       .finally(() => {
+        if (requestId !== currentRequestId) return;
         setLoading(false);
         setIsRefreshing(false);
         setLoadingPhase("complete");
+        if (pendingRefresh) {
+          pendingRefresh = false;
+          refresh();
+        }
       });
   };
 

package/src/tui/types/index.ts

@@ -31,6 +31,7 @@ export interface DailyEntry {
 export interface ContributionDay {
   date: string;
   cost: number;
+  tokens: number;
   level: number;
 }
 

package/src/wrapped.ts

@@ -11,6 +11,7 @@ import {
 } from "./native.js";
 import { PricingFetcher } from "./pricing.js";
 import { syncCursorCache, loadCursorCredentials } from "./cursor.js";
+import { loadCredentials } from "./credentials.js";
 import type { SourceType } from "./graph-types.js";
 
 interface WrappedData {
@@ -24,6 +25,7 @@ interface WrappedData {
   longestStreak: number;
   topModels: Array<{ name: string; cost: number; tokens: number }>;
   topClients: Array<{ name: string; cost: number; tokens: number }>;
+  topAgents?: Array<{ name: string; cost: number; tokens: number; messages: number }>;
   contributions: Array<{ date: string; level: 0 | 1 | 2 | 3 | 4 }>;
   totalMessages: number;
 }
@@ -33,6 +35,8 @@ export interface WrappedOptions {
   year?: string;
   sources?: SourceType[];
   short?: boolean;
+  includeAgents?: boolean;
+  pinSisyphus?: boolean;
 }
 
 const SCALE = 2;
@@ -61,16 +65,63 @@ const SOURCE_DISPLAY_NAMES: Record<string, string> = {
   cursor: "Cursor IDE",
 };
 
-const ASSETS_BASE_URL = "https://tokscale.ai/assets";
+const ASSETS_BASE_URL = "https://tokscale.ai/assets/logos";
+
+const PINNED_AGENTS = ["Sisyphus", "Planner-Sisyphus"];
+
+function normalizeAgentName(agent: string): string {
+  const agentLower = agent.toLowerCase();
+
+  if (agentLower.includes("plan")) {
+    if (agentLower.includes("omo") || agentLower.includes("sisyphus")) {
+      return "Planner-Sisyphus";
+    }
+    return agent;
+  }
+
+  if (agentLower === "omo" || agentLower === "sisyphus") {
+    return "Sisyphus";
+  }
+
+  return agent;
+}
 
 const CLIENT_LOGO_URLS: Record<string, string> = {
-  "OpenCode": `${ASSETS_BASE_URL}/client-opencode.png`,
-  "Claude Code": `${ASSETS_BASE_URL}/client-claude.jpg`,
-  "Codex CLI": `${ASSETS_BASE_URL}/client-openai.jpg`,
-  "Gemini CLI": `${ASSETS_BASE_URL}/client-gemini.png`,
-  "Cursor IDE": `${ASSETS_BASE_URL}/client-cursor.jpg`,
+  "OpenCode": `${ASSETS_BASE_URL}/opencode.png`,
+  "Claude Code": `${ASSETS_BASE_URL}/claude.jpg`,
+  "Codex CLI": `${ASSETS_BASE_URL}/openai.jpg`,
+  "Gemini CLI": `${ASSETS_BASE_URL}/gemini.png`,
+  "Cursor IDE": `${ASSETS_BASE_URL}/cursor.jpg`,
 };
 
+const PROVIDER_LOGO_URLS: Record<string, string> = {
+  "anthropic": `${ASSETS_BASE_URL}/claude.jpg`,
+  "openai": `${ASSETS_BASE_URL}/openai.jpg`,
+  "google": `${ASSETS_BASE_URL}/gemini.png`,
+  "xai": `${ASSETS_BASE_URL}/grok.jpg`,
+  "zai": `${ASSETS_BASE_URL}/zai.jpg`,
+};
+
+function getProviderFromModel(modelId: string): string | null {
+  const lower = modelId.toLowerCase();
+  if (lower.includes("claude") || lower.includes("opus") || lower.includes("sonnet") || lower.includes("haiku")) {
+    return "anthropic";
+  }
+  if (lower.includes("gpt") || lower.includes("o1") || lower.includes("o3") || lower.includes("codex")) {
+    return "openai";
+  }
+  if (lower.includes("gemini")) {
+    return "google";
+  }
+  if (lower.includes("grok")) {
+    return "xai";
+  }
+  if (lower.includes("glm") || lower.includes("pickle")) {
+    return "zai";
+  }
+  return null;
+}
+
 const TOKSCALE_LOGO_SVG_URL = "https://tokscale.ai/tokscale-logo.svg";
 const TOKSCALE_LOGO_PNG_SIZE = 400;
 
@@ -171,7 +222,7 @@ async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
     pricingFetcher.fetchPricing(),
     includeCursor && loadCursorCredentials() ? syncCursorCache() : Promise.resolve({ synced: false, rows: 0 }),
     localSources.length > 0
-      ? parseLocalSourcesAsync({ sources: localSources, since, until, year })
+      ? parseLocalSourcesAsync({ sources: localSources, since, until, year, forceTypescript: options.includeAgents })
       : Promise.resolve({ messages: [], opencodeCount: 0, claudeCount: 0, codexCount: 0, geminiCount: 0, processingTimeMs: 0 } as ParsedMessages),
   ]);
 
@@ -247,6 +298,54 @@ async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
     .sort((a, b) => b.cost - a.cost)
     .slice(0, 3);
 
+  let topAgents: Array<{ name: string; cost: number; tokens: number; messages: number }> | undefined;
+  if (options.includeAgents && localMessages) {
+    const pricingEntries = pricingFetcher.toPricingEntries();
+    const pricingMap = new Map(pricingEntries.map(p => [p.modelId, p.pricing]));
+
+    const agentMap = new Map<string, { cost: number; tokens: number; messages: number }>();
+    for (const msg of localMessages.messages) {
+      if (msg.source === "opencode" && msg.agent) {
+        const normalizedAgent = normalizeAgentName(msg.agent);
+        const existing = agentMap.get(normalizedAgent) || { cost: 0, tokens: 0, messages: 0 };
+
+        const msgTokens = msg.input + msg.output + msg.cacheRead + msg.cacheWrite + msg.reasoning;
+        const pricing = pricingMap.get(msg.modelId);
+        let msgCost = 0;
+        if (pricing) {
+          msgCost = (msg.input * pricing.inputCostPerToken) +
+                    (msg.output * pricing.outputCostPerToken) +
+                    (msg.cacheRead * (pricing.cacheReadInputTokenCost || 0)) +
+                    (msg.cacheWrite * (pricing.cacheCreationInputTokenCost || 0));
+        }
+
+        agentMap.set(normalizedAgent, {
+          cost: existing.cost + msgCost,
+          tokens: existing.tokens + msgTokens,
+          messages: existing.messages + 1,
+        });
+      }
+    }
+
+    let agentsList = Array.from(agentMap.entries())
+      .map(([name, data]) => ({ name, ...data }));
+
+    if (options.pinSisyphus) {
+      const pinned = agentsList.filter(a => PINNED_AGENTS.includes(a.name));
+      const unpinned = agentsList.filter(a => !PINNED_AGENTS.includes(a.name));
+
+      pinned.sort((a, b) => PINNED_AGENTS.indexOf(a.name) - PINNED_AGENTS.indexOf(b.name));
+      unpinned.sort((a, b) => b.messages - a.messages);
+
+      agentsList = [...pinned, ...unpinned.slice(0, 2)];
+    } else {
+      agentsList.sort((a, b) => b.messages - a.messages);
+      agentsList = agentsList.slice(0, 3);
+    }
+
+    topAgents = agentsList.length > 0 ? agentsList : undefined;
+  }
+
   const maxCost = Math.max(...graph.contributions.map(c => c.totals.cost), 1);
   const contributions = graph.contributions.map(c => ({
     date: c.date,
@@ -269,6 +368,7 @@ async function loadWrappedData(options: WrappedOptions): Promise<WrappedData> {
     longestStreak,
     topModels,
     topClients,
+    topAgents,
     contributions,
     totalMessages: report.totalMessages,
   };
@@ -526,7 +626,7 @@ function formatDate(dateStr: string): string {
   return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
 }
 
-async function generateWrappedImage(data: WrappedData, options: { short?: boolean } = {}): Promise<Buffer> {
+async function generateWrappedImage(data: WrappedData, options: { short?: boolean; includeAgents?: boolean; pinSisyphus?: boolean } = {}): Promise<Buffer> {
   await ensureFontsLoaded();
   
   const canvas = createCanvas(IMAGE_WIDTH, IMAGE_HEIGHT);
@@ -541,9 +641,19 @@ async function generateWrappedImage(data: WrappedData, options: { short?: boolea
 
   let yPos = PADDING + 24 * SCALE;
 
-  ctx.fillStyle = COLORS.textSecondary;
-  ctx.font = `${24 * SCALE}px Figtree, sans-serif`;
-  ctx.fillText(`Tracking since ${formatDate(data.firstDay)}`, PADDING, yPos);
+  const credentials = loadCredentials();
+  const MAX_USERNAME_LENGTH = 30; // GitHub max is 39, but leave room for layout
+  const displayUsername = credentials?.username
+    ? credentials.username.length > MAX_USERNAME_LENGTH
+      ? credentials.username.substring(0, MAX_USERNAME_LENGTH - 1) + '…'
+      : credentials.username
+    : null;
+  const titleText = displayUsername
+    ? `@${displayUsername}'s Wrapped ${data.year}`
+    : `My Wrapped ${data.year}`;
+  ctx.fillStyle = COLORS.textPrimary;
+  ctx.font = `bold ${28 * SCALE}px Figtree, sans-serif`;
+  ctx.fillText(titleText, PADDING, yPos);
   yPos += 60 * SCALE;
 
   ctx.fillStyle = COLORS.textSecondary;
@@ -559,6 +669,9 @@ async function generateWrappedImage(data: WrappedData, options: { short?: boolea
   ctx.fillText(totalTokensDisplay, PADDING, yPos);
   yPos += 50 * SCALE + 40 * SCALE;
 
+  const logoSize = 32 * SCALE;
+  const logoRadius = 6 * SCALE;
+
   ctx.fillStyle = COLORS.textSecondary;
   ctx.font = `${20 * SCALE}px Figtree, sans-serif`;
   ctx.fillText("Top Models", PADDING, yPos);
@@ -569,57 +682,118 @@ async function generateWrappedImage(data: WrappedData, options: { short?: boolea
     ctx.fillStyle = COLORS.textPrimary;
     ctx.font = `bold ${32 * SCALE}px Figtree, sans-serif`;
     ctx.fillText(`${i + 1}`, PADDING, yPos);
-    
-    ctx.font = `${32 * SCALE}px Figtree, sans-serif`;
-    ctx.fillText(formatModelName(model.name), PADDING + 40 * SCALE, yPos);
-    yPos += 50 * SCALE;
-  }
-  yPos += 40 * SCALE;
 
-  ctx.fillStyle = COLORS.textSecondary;
-  ctx.font = `${20 * SCALE}px Figtree, sans-serif`;
-  ctx.fillText("Top Clients", PADDING, yPos);
-  yPos += 48 * SCALE;
+    const provider = getProviderFromModel(model.name);
+    const providerLogoUrl = provider ? PROVIDER_LOGO_URLS[provider] : null;
+    let textX = PADDING + 40 * SCALE;
 
-  const logoSize = 32 * SCALE;
-  
-  for (let i = 0; i < data.topClients.length; i++) {
-    const client = data.topClients[i];
-    ctx.fillStyle = COLORS.textPrimary;
-    ctx.font = `bold ${32 * SCALE}px Figtree, sans-serif`;
-    ctx.fillText(`${i + 1}`, PADDING, yPos);
-    
-    const logoUrl = CLIENT_LOGO_URLS[client.name];
-    if (logoUrl) {
+    if (providerLogoUrl) {
       try {
-        const filename = `client-${client.name.toLowerCase().replace(/\s+/g, "-")}@2x.png`;
-        const logoPath = await fetchAndCacheImage(logoUrl, filename);
+        const filename = `provider-${provider}@2x.jpg`;
+        const logoPath = await fetchAndCacheImage(providerLogoUrl, filename);
         const logo = await loadImage(logoPath);
         const logoY = yPos - logoSize + 6 * SCALE;
-        
         const logoX = PADDING + 40 * SCALE;
-        const logoRadius = 6 * SCALE;
-        
+
         ctx.save();
         drawRoundedRect(ctx, logoX, logoY, logoSize, logoSize, logoRadius);
         ctx.clip();
         ctx.drawImage(logo, logoX, logoY, logoSize, logoSize);
         ctx.restore();
-        
+
         drawRoundedRect(ctx, logoX, logoY, logoSize, logoSize, logoRadius);
         ctx.strokeStyle = "#141A25";
         ctx.lineWidth = 1 * SCALE;
         ctx.stroke();
+
+        textX = logoX + logoSize + 12 * SCALE;
       } catch {
       }
     }
-    
+
+    ctx.fillStyle = COLORS.textPrimary;
     ctx.font = `${32 * SCALE}px Figtree, sans-serif`;
-    ctx.fillText(client.name, PADDING + 40 * SCALE + logoSize + 12 * SCALE, yPos);
+    ctx.fillText(formatModelName(model.name), textX, yPos);
     yPos += 50 * SCALE;
   }
   yPos += 40 * SCALE;
 
+  if (options.includeAgents) {
+    ctx.fillStyle = COLORS.textSecondary;
+    ctx.font = `${20 * SCALE}px Figtree, sans-serif`;
+    ctx.fillText("Top OpenCode Agents", PADDING, yPos);
+    yPos += 48 * SCALE;
+
+    const agents = data.topAgents || [];
+    const SISYPHUS_COLOR = "#00CED1";
+    let rankIndex = 1;
+
+    for (let i = 0; i < agents.length; i++) {
+      const agent = agents[i];
+      const isSisyphusAgent = PINNED_AGENTS.includes(agent.name);
+      const showWithDash = options.pinSisyphus && isSisyphusAgent;
+
+      ctx.fillStyle = showWithDash ? SISYPHUS_COLOR : COLORS.textPrimary;
+      ctx.font = `bold ${32 * SCALE}px Figtree, sans-serif`;
+      const prefix = showWithDash ? "•" : `${rankIndex}`;
+      ctx.fillText(prefix, PADDING, yPos);
+      if (!showWithDash) rankIndex++;
+
+      const nameX = PADDING + 40 * SCALE;
+      ctx.font = `${32 * SCALE}px Figtree, sans-serif`;
+      ctx.fillStyle = isSisyphusAgent ? SISYPHUS_COLOR : COLORS.textPrimary;
+      ctx.fillText(agent.name, nameX, yPos);
+
+      const nameWidth = ctx.measureText(agent.name).width;
+      ctx.fillStyle = COLORS.textSecondary;
+      ctx.fillText(` (${agent.messages.toLocaleString()})`, nameX + nameWidth, yPos);
+
+      yPos += 50 * SCALE;
+    }
+  } else {
+    ctx.fillStyle = COLORS.textSecondary;
+    ctx.font = `${20 * SCALE}px Figtree, sans-serif`;
+    ctx.fillText("Top Clients", PADDING, yPos);
+    yPos += 48 * SCALE;
+
+    for (let i = 0; i < data.topClients.length; i++) {
+      const client = data.topClients[i];
+      ctx.fillStyle = COLORS.textPrimary;
+      ctx.font = `bold ${32 * SCALE}px Figtree, sans-serif`;
+      ctx.fillText(`${i + 1}`, PADDING, yPos);
+
+      const logoUrl = CLIENT_LOGO_URLS[client.name];
+      if (logoUrl) {
+        try {
+          const filename = `client-${client.name.toLowerCase().replace(/\s+/g, "-")}@2x.png`;
+          const logoPath = await fetchAndCacheImage(logoUrl, filename);
+          const logo = await loadImage(logoPath);
+          const logoY = yPos - logoSize + 6 * SCALE;
+
+          const logoX = PADDING + 40 * SCALE;
+          const logoRadius = 6 * SCALE;
+
+          ctx.save();
+          drawRoundedRect(ctx, logoX, logoY, logoSize, logoSize, logoRadius);
+          ctx.clip();
+          ctx.drawImage(logo, logoX, logoY, logoSize, logoSize);
+          ctx.restore();
+
+          drawRoundedRect(ctx, logoX, logoY, logoSize, logoSize, logoRadius);
+          ctx.strokeStyle = "#141A25";
+          ctx.lineWidth = 1 * SCALE;
+          ctx.stroke();
+        } catch {
+        }
+      }
+
+      ctx.font = `${32 * SCALE}px Figtree, sans-serif`;
+      ctx.fillText(client.name, PADDING + 40 * SCALE + logoSize + 12 * SCALE, yPos);
+      yPos += 50 * SCALE;
+    }
+  }
+  yPos += 40 * SCALE;
+
   const statsStartY = yPos;
   const statWidth = (leftWidth - PADDING * 2) / 2;
 
@@ -660,11 +834,15 @@ async function generateWrappedImage(data: WrappedData, options: { short?: boolea
 
 export async function generateWrapped(options: WrappedOptions): Promise<string> {
   const data = await loadWrappedData(options);
-  const imageBuffer = await generateWrappedImage(data, { short: options.short });
-  
+  const imageBuffer = await generateWrappedImage(data, {
+    short: options.short,
+    includeAgents: options.includeAgents,
+    pinSisyphus: options.pinSisyphus,
+  });
+
   const outputPath = options.output || `tokscale-${data.year}-wrapped.png`;
   const absolutePath = path.resolve(outputPath);
-  
+
   fs.writeFileSync(absolutePath, imageBuffer);
 
   return absolutePath;