@mauricode/token-derby 2.9.0 → 2.10.1

package/dist/bin.js

@@ -24,6 +24,22 @@ import { useState as useState2 } from "react";
 import { Box as Box3, Text as Text3, useInput } from "ink";
 import TextInput from "ink-text-input";
 
+// ../shared/dist/models.js
+var MODEL_KEYS = ["claude", "codex", "gemini"];
+var SECONDARY_WEIGHT = 0.1;
+function isModelKey(v) {
+  return typeof v === "string" && MODEL_KEYS.includes(v);
+}
+function weightFor(primary, key) {
+  return key === primary ? 1 : SECONDARY_WEIGHT;
+}
+function weightedTotal(primary, perSource) {
+  let total = 0;
+  for (const key of MODEL_KEYS)
+    total += perSource[key] * weightFor(primary, key);
+  return total;
+}
+
 // ../shared/dist/constants.js
 var CLI_VERSION_HEADER = "x-cli-version";
 var USER_ID_HEADER = "x-user-id";
@@ -724,8 +740,8 @@ var HEARTBEAT_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
 // src/version.ts
 import { createRequire } from "module";
 function readVersion() {
-  if ("2.9.0".length > 0) {
-    return "2.9.0";
+  if ("2.10.1".length > 0) {
+    return "2.10.1";
   }
   try {
     const req = createRequire(import.meta.url);
@@ -759,6 +775,12 @@ function activeRacesDir() {
 function claudeProjectsDir() {
   return process.env.TOKEN_DERBY_CLAUDE_DIR ?? path.join(os.homedir(), ".claude", "projects");
 }
+function codexSessionsDir() {
+  return process.env.TOKEN_DERBY_CODEX_DIR ?? path.join(os.homedir(), ".codex");
+}
+function geminiTmpDir() {
+  return process.env.TOKEN_DERBY_GEMINI_DIR ?? path.join(os.homedir(), ".gemini", "tmp");
+}
 
 // src/identity/identity.ts
 async function loadIdentity() {
@@ -813,8 +835,8 @@ function getIdentity() {
 function _resetIdentityCacheForTests() {
   identityCache = null;
 }
-async function request(method, path5, body, horseAuthToken, fetchImpl = fetch) {
-  const url = path5.startsWith("http") ? path5 : `${apiBase()}${path5}`;
+async function request(method, path7, body, horseAuthToken, fetchImpl = fetch) {
+  const url = path7.startsWith("http") ? path7 : `${apiBase()}${path7}`;
   const headers = {};
   headers[CLI_VERSION_HEADER] = CLI_VERSION;
   headers["user-agent"] = `token-derby/${CLI_VERSION}`;
@@ -1302,6 +1324,8 @@ async function createRaceCommand(organisationName) {
     }
     const countInputRaw = (await rl.question("Count input tokens (fresh input + cache creation) toward race totals? [y/N]: ")).trim().toLowerCase();
     const counts_input = countInputRaw === "y" || countInputRaw === "yes";
+    const top5Raw = (await rl.question("Count only each racer's 5 most-active conversations toward their primary model's score? [y/N]: ")).trim().toLowerCase();
+    const primary_top5 = top5Raw === "y" || top5Raw === "yes";
     const resp = await createRace({
       name,
       start_time: start,
@@ -1309,7 +1333,8 @@ async function createRaceCommand(organisationName) {
       tz,
       ...max !== void 0 ? { max_participants: max } : {},
       ...org ? { organisation_name: org } : {},
-      ...counts_input ? { counts_input: true } : {}
+      ...counts_input ? { counts_input: true } : {},
+      ...primary_top5 ? { primary_top5: true } : {}
     });
     console.log("");
     console.log("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
@@ -1325,6 +1350,9 @@ async function createRaceCommand(organisationName) {
     if (counts_input) {
       console.log("  Counting input + output tokens (excluding cache reads).");
     }
+    if (primary_top5) {
+      console.log("  Primary score counts only each racer's top 5 conversations per beat.");
+    }
     console.log(`  Share with participants:  token-derby join ${resp.join_code}`);
     return 0;
   } catch (e) {
@@ -1344,9 +1372,31 @@ function isIso(s) {
 }
 
 // src/commands/join.ts
-import React8 from "react";
+import React9 from "react";
 import { render as render4 } from "ink";
 
+// src/ui/PrimaryPicker.tsx
+import { useState as useState4 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput3 } from "ink";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var LABELS = { claude: "Claude", codex: "Codex", gemini: "Gemini" };
+function PrimaryPicker({ onPick }) {
+  const [i, setI] = useState4(0);
+  useInput3((_input, key) => {
+    if (key.upArrow) setI((p) => (p + MODEL_KEYS.length - 1) % MODEL_KEYS.length);
+    else if (key.downArrow) setI((p) => (p + 1) % MODEL_KEYS.length);
+    else if (key.return) onPick(MODEL_KEYS[i]);
+  });
+  return /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Pick your primary model for this race (counts 1:1; the others count at 10%)." }),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "This is locked for the whole race \u2014 you can't change it, even by rejoining." }),
+    MODEL_KEYS.map((m, idx) => /* @__PURE__ */ jsxs4(Text6, { color: idx === i ? "cyan" : void 0, children: [
+      idx === i ? "\u276F " : "  ",
+      LABELS[m]
+    ] }, m))
+  ] });
+}
+
 // src/stable/active-race.ts
 import * as fs2 from "fs/promises";
 import * as path3 from "path";
@@ -1360,45 +1410,58 @@ async function saveActiveRace(active) {
 }
 
 // src/runtime/run-race.tsx
-import { useEffect as useEffect2, useRef, useState as useState4 } from "react";
-import { Box as Box7, Text as Text7, useApp } from "ink";
+import { useEffect as useEffect2, useRef, useState as useState5 } from "react";
+import { Box as Box8, Text as Text8, useApp } from "ink";
 
 // src/ui/StatusScreen.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var MODEL_LABELS = { claude: "Claude", codex: "Codex", gemini: "Gemini" };
+function TokenBreakdown(props) {
+  const { primaryModel, perSource, raceScore, primaryCapped } = props;
+  const primaryTag = primaryCapped ? "(primary \xB7 top 5/beat)" : "(primary)";
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Tokens by model (since join)" }),
+    MODEL_KEYS.map((m) => /* @__PURE__ */ jsxs5(Text7, { children: [
+      `  ${MODEL_LABELS[m].padEnd(10)} ${perSource[m].toLocaleString().padStart(12)}  `,
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: m === primaryModel ? primaryTag : "(10%)" })
+    ] }, m)),
+    /* @__PURE__ */ jsx7(Text7, { children: `  ${"Race score".padEnd(10)} ${Math.round(raceScore).toLocaleString().padStart(12)}` })
+  ] });
+}
 function StatusScreen(props) {
-  const { race, ownHorseId, ownHorseName, ownColors, ownUserName, lastHeartbeatAgoSec, lastHeartbeatOk, stalled } = props;
+  const { race, ownHorseId, ownHorseName, ownColors, ownUserName, lastHeartbeatAgoSec, lastHeartbeatOk, stalled, stallReason, primaryModel, perSource, primaryCapped } = props;
   if (!race) {
-    return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsx6(Text6, { children: "Joining race\u2026" }) });
+    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx7(Text7, { children: "Joining race\u2026" }) });
   }
   const own = race.horses.find((h) => h.horse_id === ownHorseId);
   const leader = race.horses[0];
   const elapsedPct = elapsed(race);
   const timeLeft = formatDuration(race.time_left_seconds);
   const lvl = levelInfo((own?.xp ?? 0) + (own?.live_xp ?? 0));
-  return /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs4(Text6, { children: [
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs5(Text7, { children: [
       "\u{1F3C7} TOKEN DERBY \u2500\u2500\u2500 ",
-      /* @__PURE__ */ jsx6(Text6, { bold: true, children: race.name }),
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: race.name }),
       " \u2500\u2500\u2500 status: ",
-      /* @__PURE__ */ jsx6(Text6, { color: statusColor(race.status), children: race.status })
+      /* @__PURE__ */ jsx7(Text7, { color: statusColor(race.status), children: race.status })
     ] }),
-    /* @__PURE__ */ jsxs4(Box6, { marginTop: 1, flexDirection: "row", children: [
-      /* @__PURE__ */ jsx6(HorseSprite, { sprite: MINI_SPRITE, colors: ownColors }),
-      /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsxs4(Text6, { children: [
+    /* @__PURE__ */ jsxs5(Box7, { marginTop: 1, flexDirection: "row", children: [
+      /* @__PURE__ */ jsx7(HorseSprite, { sprite: MINI_SPRITE, colors: ownColors }),
+      /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs5(Text7, { children: [
           "  ",
           ownHorseName,
           " ",
-          /* @__PURE__ */ jsxs4(Text6, { color: "cyan", children: [
+          /* @__PURE__ */ jsxs5(Text7, { color: "cyan", children: [
             "[Lvl. ",
             lvl.level,
             "]"
           ] })
         ] }),
-        /* @__PURE__ */ jsxs4(Text6, { children: [
+        /* @__PURE__ */ jsxs5(Text7, { children: [
           "  ",
-          /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "(",
             ownUserName,
             ")"
@@ -1406,44 +1469,57 @@ function StatusScreen(props) {
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+    /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Tokens (race):  ",
         own?.current_tokens ?? 0
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Position:       ",
         own?.rank ?? "\u2014",
         " of ",
         race.horses.length
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Leader:         ",
         leader ? `${leader.name}${leader.user_name ? ` (${leader.user_name})` : ""} \u2014 ${leader.current_tokens}` : "\u2014"
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Race elapsed:   ",
         (elapsedPct * 100).toFixed(0),
         "%  ",
         bar(elapsedPct, 20)
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Time left:      ",
         timeLeft
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "XP:             ",
         lvl.next_level_xp === null ? `${lvl.xp} (max level)  ${bar(1, 20)}` : `${lvl.xp_into_level}/${lvl.xp_for_level} \u2192 Lvl. ${lvl.level + 1}  ${bar(lvl.progress, 20)}`
       ] }),
-      /* @__PURE__ */ jsxs4(Text6, { children: [
+      /* @__PURE__ */ jsxs5(Text7, { children: [
         "Last heartbeat: ",
         lastHeartbeatAgoSec === null ? "\u2014" : `${lastHeartbeatAgoSec}s ago`,
         " ",
-        /* @__PURE__ */ jsx6(Text6, { color: lastHeartbeatOk ? "green" : "yellow", children: lastHeartbeatOk ? "\u2713" : "\u26A0" })
+        /* @__PURE__ */ jsx7(Text7, { color: lastHeartbeatOk ? "green" : "yellow", children: lastHeartbeatOk ? "\u2713" : "\u26A0" })
       ] }),
-      stalled && /* @__PURE__ */ jsx6(Text6, { color: "yellow", children: "\u26A0 Can't read token usage \u2014 try restarting this terminal. Your race continues." })
+      stalled && /* @__PURE__ */ jsxs5(Text7, { color: "yellow", children: [
+        "\u26A0 ",
+        stallReason ?? "Can't read token usage",
+        ". Your race continues."
+      ] })
     ] }),
-    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Press Ctrl+C to crash out of the race." }) })
+    primaryModel && perSource && /* @__PURE__ */ jsx7(
+      TokenBreakdown,
+      {
+        primaryModel,
+        perSource,
+        raceScore: own?.current_tokens ?? weightedTotal(primaryModel, perSource),
+        primaryCapped
+      }
+    ),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press Ctrl+C to crash out of the race." }) })
   ] });
 }
 function elapsed(race) {
@@ -1515,30 +1591,45 @@ function runHeartbeatLoop(opts) {
 // src/tokens/transcripts.ts
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
-async function sumTokens() {
+var MAX_PROJECT_DEPTH = 8;
+function conversationId(file, root) {
+  const rel = path4.relative(root, file);
+  const [project, session] = rel.split(path4.sep);
+  if (project === void 0 || session === void 0) return rel.replace(/\.jsonl$/, "");
+  return `${project}/${session.replace(/\.jsonl$/, "")}`;
+}
+async function sumTokensByConversation() {
   const root = claudeProjectsDir();
   const files = await listJsonlFiles(root);
-  let input = 0;
-  let output = 0;
+  const byConv = /* @__PURE__ */ new Map();
   for (const file of files) {
     const t = await sumFile(file);
+    const id = conversationId(file, root);
+    const acc = byConv.get(id) ?? { input: 0, output: 0 };
+    acc.input += t.input;
+    acc.output += t.output;
+    byConv.set(id, acc);
+  }
+  return byConv;
+}
+async function sumTokens() {
+  const byConv = await sumTokensByConversation();
+  let input = 0;
+  let output = 0;
+  for (const t of byConv.values()) {
     input += t.input;
     output += t.output;
   }
   return { input, output };
 }
-async function sumTokensForRace(race) {
-  const { input, output } = await sumTokens();
-  return race.counts_input ? input + output : output;
-}
 async function listJsonlFiles(root) {
   const projects = await fs3.readdir(root);
   const out = [];
   for (const project of projects) {
     const projectDir = path4.join(root, project);
-    const stat2 = await fs3.stat(projectDir);
-    if (!stat2.isDirectory()) continue;
-    await collectJsonl(projectDir, 3, out);
+    const stat3 = await fs3.stat(projectDir);
+    if (!stat3.isDirectory()) continue;
+    await collectJsonl(projectDir, MAX_PROJECT_DEPTH, out);
   }
   return out;
 }
@@ -1578,68 +1669,342 @@ async function sumFile(file) {
   return { input, output };
 }
 
+// src/tokens/codex.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+async function sumCodexByConversation() {
+  const root = codexSessionsDir();
+  await fs4.stat(root);
+  const files = [
+    ...await collectRollouts(path5.join(root, "sessions")),
+    ...await collectRollouts(path5.join(root, "archived_sessions"))
+  ];
+  const byConv = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byConv.set(file, await lastTokenCount(file));
+  }
+  return byConv;
+}
+async function sumCodexTokens() {
+  const byConv = await sumCodexByConversation();
+  let input = 0;
+  let output = 0;
+  for (const t of byConv.values()) {
+    input += t.input;
+    output += t.output;
+  }
+  return { input, output };
+}
+async function collectRollouts(dir) {
+  let entries;
+  try {
+    entries = await fs4.readdir(dir, { withFileTypes: true });
+  } catch (e) {
+    if (e?.code === "ENOENT") return [];
+    throw e;
+  }
+  const out = [];
+  for (const entry of entries) {
+    const full = path5.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...await collectRollouts(full));
+    else if (entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) out.push(full);
+  }
+  return out;
+}
+async function lastTokenCount(file) {
+  let raw;
+  try {
+    raw = await fs4.readFile(file, "utf8");
+  } catch {
+    return { input: 0, output: 0 };
+  }
+  let usage = null;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (parsed?.payload?.type === "token_count" && parsed.payload.info?.total_token_usage) {
+      usage = parsed.payload.info.total_token_usage;
+    }
+  }
+  if (!usage) return { input: 0, output: 0 };
+  return {
+    input: Math.max(0, num(usage.input_tokens) - num(usage.cached_input_tokens)),
+    output: num(usage.output_tokens)
+  };
+}
+
+// src/tokens/gemini.ts
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
+function num2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+async function sumGeminiByConversation() {
+  const files = await listChatFiles(geminiTmpDir());
+  const byConv = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byConv.set(file, await sumGeminiFile(file));
+  }
+  return byConv;
+}
+async function sumGeminiTokens() {
+  const byConv = await sumGeminiByConversation();
+  let input = 0;
+  let output = 0;
+  for (const t of byConv.values()) {
+    input += t.input;
+    output += t.output;
+  }
+  return { input, output };
+}
+async function listChatFiles(root) {
+  const entries = await fs5.readdir(root);
+  const out = [];
+  for (const entry of entries) {
+    const chatsDir = path6.join(root, entry, "chats");
+    let files;
+    try {
+      files = await fs5.readdir(chatsDir);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      if (f.endsWith(".json") || f.endsWith(".jsonl")) out.push(path6.join(chatsDir, f));
+    }
+  }
+  return out;
+}
+async function sumGeminiFile(file) {
+  let raw;
+  try {
+    raw = await fs5.readFile(file, "utf8");
+  } catch {
+    return { input: 0, output: 0 };
+  }
+  const messages = file.endsWith(".jsonl") ? parseJsonl(raw) : parseJson(raw);
+  let input = 0;
+  let output = 0;
+  for (const m of messages) {
+    const tk = m?.tokens;
+    if (!tk || typeof tk !== "object") continue;
+    input += Math.max(0, num2(tk.input) - num2(tk.cached));
+    output += num2(tk.output);
+  }
+  return { input, output };
+}
+function parseJson(raw) {
+  try {
+    const data = JSON.parse(raw);
+    return Array.isArray(data?.messages) ? data.messages : [];
+  } catch {
+    return [];
+  }
+}
+function parseJsonl(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/tokens/race-tokens.ts
+function isStall(r) {
+  return "stall" in r;
+}
+var SCALAR_READERS = {
+  claude: sumTokens,
+  codex: sumCodexTokens,
+  gemini: sumGeminiTokens
+};
+var BY_CONVERSATION_READERS = {
+  claude: sumTokensByConversation,
+  codex: sumCodexByConversation,
+  gemini: sumGeminiByConversation
+};
+function scoreFor(race, t) {
+  return race.counts_input ? t.input + t.output : t.output;
+}
+async function readAllSources(race, primary) {
+  const primaryByConv = /* @__PURE__ */ new Map();
+  try {
+    const primaryMap = await BY_CONVERSATION_READERS[primary]();
+    for (const [id, totals] of primaryMap) primaryByConv.set(id, scoreFor(race, totals));
+  } catch (e) {
+    if (e?.code !== "ENOENT") {
+      return { stall: `Can't read ${primary} token usage: ${e?.message ?? String(e)}` };
+    }
+  }
+  const secondary = { claude: 0, codex: 0, gemini: 0 };
+  await Promise.all(
+    MODEL_KEYS.filter((k) => k !== primary).map(async (k) => {
+      secondary[k] = await SCALAR_READERS[k]().then((t) => scoreFor(race, t)).catch(() => 0);
+    })
+  );
+  return { secondary, primaryByConv };
+}
+
+// src/tokens/primary-cap.ts
+var PRIMARY_TOP_CONVERSATIONS = 5;
+function primaryConversationCap(enabled) {
+  return enabled ? PRIMARY_TOP_CONVERSATIONS : Infinity;
+}
+
 // src/tokens/race-score.ts
 var STALL_THRESHOLD = 5;
+function zero() {
+  return { claude: 0, codex: 0, gemini: 0 };
+}
 var RaceScoreTracker = class {
   acked;
   lastGood;
+  primaryConvAcked;
+  primaryConvLast;
+  counted;
   seq;
   stalls = 0;
-  constructor(init) {
-    this.acked = init.ackedReading;
-    this.lastGood = init.lastGoodReading;
+  lastStall = null;
+  primary;
+  primaryTop5;
+  constructor(init, primary, primaryTop5) {
+    this.acked = { ...init.acked };
+    this.lastGood = { ...init.lastGood };
+    this.primaryConvAcked = { ...init.primaryConvAcked };
+    this.primaryConvLast = { ...init.primaryConvAcked };
+    this.counted = init.primaryCounted;
     this.seq = init.seq;
+    this.primary = primary;
+    this.primaryTop5 = primaryTop5;
   }
   /**
    * Record a scan result.
-   * - `null` → scan failed/timed-out/missing dir: a stall (counts toward the warning), anchors untouched.
-   * - `0` → readable but empty: the read mechanism works (resets the stall counter), but we never anchor to 0.
-   * - `> 0` → real reading; follows up or down.
+   * - `null` or a `{ stall }` reading → stall (warning), anchors untouched. A
+   *   stall reading also captures its cause for the UI.
+   * - otherwise → secondaries advance scalar lastGood (never down to 0); the
+   *   primary's per-conversation latest readings are updated (monotonic).
    */
   recordReading(reading) {
-    if (reading === null) {
+    if (reading === null || isStall(reading)) {
       this.stalls += 1;
+      this.lastStall = reading?.stall ?? null;
       return;
     }
     this.stalls = 0;
-    if (reading > 0) this.lastGood = reading;
+    this.lastStall = null;
+    for (const key of MODEL_KEYS) {
+      if (key === this.primary) continue;
+      const v = reading.secondary[key];
+      if (v > 0) this.lastGood[key] = v;
+    }
+    for (const [id, v] of reading.primaryByConv) {
+      const prev = this.primaryConvLast[id] ?? 0;
+      if (v > prev) this.primaryConvLast[id] = v;
+    }
   }
   /** Frozen payload for the next heartbeat. Pure — call repeatedly for retries. */
   nextBeat() {
-    return { seq: this.seq + 1, delta: Math.max(0, this.lastGood - this.acked), reading: this.lastGood };
+    const components = zero();
+    for (const key of MODEL_KEYS) {
+      if (key === this.primary) continue;
+      components[key] = Math.max(0, this.lastGood[key] - this.acked[key]);
+    }
+    const pending = [];
+    for (const [id, last] of Object.entries(this.primaryConvLast)) {
+      const d = Math.max(0, last - (this.primaryConvAcked[id] ?? 0));
+      if (d > 0) pending.push(d);
+    }
+    pending.sort((a, b) => b - a);
+    const cap = primaryConversationCap(this.primaryTop5);
+    const take = cap === Infinity ? pending.length : Math.min(cap, pending.length);
+    let primarySum = 0;
+    for (const d of pending.slice(0, take)) primarySum += d;
+    components[this.primary] = primarySum;
+    return {
+      seq: this.seq + 1,
+      components,
+      readings: { ...this.lastGood },
+      primaryConvReadings: { ...this.primaryConvLast }
+    };
   }
   /** Commit a heartbeat the server accepted. `serverLastSeq` self-heals drift. */
   ack(snapshot, serverLastSeq) {
-    this.acked = snapshot.reading;
+    for (const key of MODEL_KEYS) {
+      if (key === this.primary) continue;
+      this.acked[key] = snapshot.readings[key];
+    }
+    this.primaryConvAcked = { ...snapshot.primaryConvReadings };
+    this.counted += snapshot.components[this.primary];
     this.seq = Math.max(snapshot.seq, serverLastSeq);
   }
-  /** Pin the anchor to the latest reading so the next delta is 0 (used while a race is pending). */
+  /** Pin anchors to the latest readings so the next deltas are 0 (pending race). */
   reprime() {
-    this.acked = this.lastGood;
+    for (const key of MODEL_KEYS) {
+      if (key === this.primary) continue;
+      this.acked[key] = this.lastGood[key];
+    }
+    this.primaryConvAcked = { ...this.primaryConvLast };
   }
   get stalled() {
     return this.stalls >= STALL_THRESHOLD;
   }
+  /** Human-readable cause of the most recent stall (null once a good read recovers). */
+  get stallReason() {
+    return this.lastStall;
+  }
+  /** Cumulative primary tokens credited so far (for the UI's primary "since join" row). */
+  primaryCounted() {
+    return this.counted;
+  }
+  /** Secondary "since join" totals = lastGood − baseline (for the UI). Primary key is 0 here. */
+  secondarySinceJoin(baseline) {
+    const out = zero();
+    for (const key of MODEL_KEYS) {
+      if (key === this.primary) continue;
+      out[key] = Math.max(0, this.lastGood[key] - baseline[key]);
+    }
+    return out;
+  }
   toState() {
-    return { ackedReading: this.acked, lastGoodReading: this.lastGood, seq: this.seq };
+    return {
+      acked: { ...this.acked },
+      lastGood: { ...this.lastGood },
+      primaryConvAcked: { ...this.primaryConvAcked },
+      primaryCounted: this.counted,
+      seq: this.seq
+    };
   }
 };
 
 // src/runtime/run-race.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 function RunRace({ active, initialState, pendingMode, ownUserName }) {
   const { exit } = useApp();
-  const [race, setRace] = useState4(null);
-  const [lastHbAt, setLastHbAt] = useState4(null);
-  const [lastHbOk, setLastHbOk] = useState4(true);
-  const [tickNow, setTickNow] = useState4(/* @__PURE__ */ new Date());
-  const [fatalError, setFatalError] = useState4(null);
-  const [achievements, setAchievements] = useState4([]);
+  const [race, setRace] = useState5(null);
+  const [lastHbAt, setLastHbAt] = useState5(null);
+  const [lastHbOk, setLastHbOk] = useState5(true);
+  const [tickNow, setTickNow] = useState5(/* @__PURE__ */ new Date());
+  const [fatalError, setFatalError] = useState5(null);
+  const [achievements, setAchievements] = useState5([]);
   const shownAchievementAtRef = useRef(0);
-  const trackerRef = useRef(new RaceScoreTracker(initialState));
+  const trackerRef = useRef(new RaceScoreTracker(initialState, active.primary_model, active.primary_top5 ?? false));
   const pendingRef = useRef(pendingMode);
   const ctrl = useRef(new AbortController());
-  const [stalled, setStalled] = useState4(false);
+  const [stalled, setStalled] = useState5(false);
+  const [stallReason, setStallReason] = useState5(null);
+  const baselineRef = useRef(initialState.acked);
+  const [perSource, setPerSource] = useState5({ claude: 0, codex: 0, gemini: 0 });
   useEffect2(() => {
     const t = setInterval(() => setTickNow(/* @__PURE__ */ new Date()), 1e3);
     return () => clearInterval(t);
@@ -1655,32 +2020,39 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
     const scanWithTimeout = async () => {
       try {
         return await Promise.race([
-          sumTokensForRace(active),
+          readAllSources(active, active.primary_model),
           new Promise((_, reject) => setTimeout(() => reject(new Error("scan timeout")), 1e4))
         ]);
       } catch {
-        return null;
+        return { stall: "Token scan timed out" };
       }
     };
     runHeartbeatLoop({
       prepareBeat: async () => {
         const reading = await scanWithTimeout();
         tracker.recordReading(reading);
-        if (pendingRef.current) tracker.reprime();
+        if (pendingRef.current && !isStall(reading)) tracker.reprime();
         setStalled(tracker.stalled);
+        setStallReason(tracker.stalled ? tracker.stallReason : null);
+        const since = tracker.secondarySinceJoin(baselineRef.current);
+        const ps = { claude: 0, codex: 0, gemini: 0 };
+        for (const k of MODEL_KEYS) {
+          ps[k] = k === active.primary_model ? tracker.primaryCounted() : since[k];
+        }
+        setPerSource(ps);
         return tracker.nextBeat();
       },
       sendBeat: async (snapshot) => {
         return heartbeat(active.join_code, active.horse_id, active.heartbeat_token, {
           seq: snapshot.seq,
-          delta: snapshot.delta
+          components: snapshot.components
         });
       },
       onSuccess: (resp, snapshot) => {
         tracker.ack(snapshot, resp.last_seq);
         const updated = {
           ...active,
-          ...tracker.toState(),
+          score: tracker.toState(),
           last_heartbeat_at: (/* @__PURE__ */ new Date()).toISOString()
         };
         void saveActiveRace(updated);
@@ -1717,13 +2089,13 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
   }, []);
   const lastHeartbeatAgoSec = lastHbAt ? Math.max(0, Math.floor((tickNow.getTime() - lastHbAt.getTime()) / 1e3)) : null;
   if (fatalError) {
-    return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", padding: 1, children: [
-      /* @__PURE__ */ jsx7(Text7, { color: "red", bold: true, children: "CLI version mismatch \u2014 disconnected" }),
-      /* @__PURE__ */ jsx7(Text7, { children: fatalError })
+    return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "red", bold: true, children: "CLI version mismatch \u2014 disconnected" }),
+      /* @__PURE__ */ jsx8(Text8, { children: fatalError })
     ] });
   }
-  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx7(
+  return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(
       StatusScreen,
       {
         race,
@@ -1733,26 +2105,30 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
         ownUserName,
         lastHeartbeatAgoSec,
         lastHeartbeatOk: lastHbOk,
-        stalled
+        stalled,
+        stallReason,
+        primaryModel: active.primary_model,
+        perSource,
+        primaryCapped: primaryConversationCap(active.primary_top5 ?? false) !== Infinity
       }
     ),
-    achievements.length > 0 && /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Achievements" }),
+    achievements.length > 0 && /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Achievements" }),
       achievements.map(({ key, event }) => {
         const description = describeAchievement(event, active);
-        return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "row", children: [
-          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
+        return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
             "  ",
             formatClockTime(event.at),
             "  "
           ] }),
-          /* @__PURE__ */ jsxs5(Text7, { color: "yellow", bold: true, children: [
+          /* @__PURE__ */ jsxs6(Text8, { color: "yellow", bold: true, children: [
             "+",
             event.xp,
             " XP  "
           ] }),
-          /* @__PURE__ */ jsx7(Text7, { children: event.name }),
-          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
+          /* @__PURE__ */ jsx8(Text8, { children: event.name }),
+          /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
             "  \u2014 ",
             description
           ] })
@@ -1778,25 +2154,54 @@ function raceViewFrom(resp) {
   };
 }
 async function buildInitialState(args) {
-  let diskNow = 0;
+  let secondary = { claude: 0, codex: 0, gemini: 0 };
+  const primaryConvAcked = {};
   try {
-    diskNow = await sumTokensForRace(args.active);
+    const now = await readAllSources(args.active, args.active.primary_model);
+    if (!isStall(now)) {
+      secondary = now.secondary;
+      for (const [id, v] of now.primaryByConv) primaryConvAcked[id] = v;
+    }
   } catch {
-    diskNow = 0;
   }
   return {
-    initialState: { ackedReading: diskNow, lastGoodReading: diskNow, seq: args.serverLastSeq },
+    initialState: {
+      acked: { ...secondary },
+      lastGood: { ...secondary },
+      primaryConvAcked,
+      primaryCounted: 0,
+      seq: args.serverLastSeq
+    },
     pendingMode: args.raceStatus === "pending"
   };
 }
 
 // src/commands/join.ts
-async function joinCommand(joinCode) {
+function parsePrimaryFlag(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    let value;
+    if (a === "--primary") value = argv[i + 1];
+    else if (a.startsWith("--primary=")) value = a.slice("--primary=".length);
+    else continue;
+    if (!isModelKey(value)) throw new Error(`--primary must be one of claude, codex, gemini (got ${value ?? ""})`);
+    return value;
+  }
+  return null;
+}
+async function joinCommand(joinCode, argv = []) {
   if (!joinCode) {
     console.error("Usage: token-derby join <join-code>");
     return 2;
   }
   const code = joinCode.toUpperCase();
+  let primaryFlag;
+  try {
+    primaryFlag = parsePrimaryFlag(argv);
+  } catch (e) {
+    console.error(e.message);
+    return 2;
+  }
   const identity = await loadIdentity();
   if (!identity) {
     console.error("Run `token-derby init` to set up your identity.");
@@ -1860,9 +2265,14 @@ async function joinCommand(joinCode) {
     chosenName = picked.name;
     chosenColors = picked.colors;
   }
+  let chosenPrimary = "claude";
+  if (!ownHorse) {
+    if (primaryFlag) chosenPrimary = primaryFlag;
+    else if (process.stdout.isTTY) chosenPrimary = await pickPrimary();
+  }
   let joinResp;
   try {
-    joinResp = await joinRace(code, { stable_horse_id: chosenStableHorseId });
+    joinResp = await joinRace(code, { stable_horse_id: chosenStableHorseId, primary_model: chosenPrimary });
   } catch (e) {
     if (e instanceof ApiError) {
       if (e.code === "RACE_FULL") console.error("This race is full.");
@@ -1887,22 +2297,28 @@ async function joinCommand(joinCode) {
     horse_name: chosenName,
     horse_colors: chosenColors,
     joined_at: ownHorse?.joined_at ?? (/* @__PURE__ */ new Date()).toISOString(),
-    ackedReading: 0,
-    lastGoodReading: 0,
-    seq: ownHorse?.last_seq ?? 0,
     last_heartbeat_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-    ...race.counts_input ? { counts_input: true } : {}
+    primary_model: joinResp.primary_model,
+    score: {
+      acked: { claude: 0, codex: 0, gemini: 0 },
+      lastGood: { claude: 0, codex: 0, gemini: 0 },
+      primaryConvAcked: {},
+      primaryCounted: 0,
+      seq: ownHorse?.last_seq ?? 0
+    },
+    ...race.counts_input ? { counts_input: true } : {},
+    ...race.primary_top5 ? { primary_top5: true } : {}
   };
   await saveActiveRace(active);
   const initial = await buildInitialState({ active, raceStatus: status, serverLastSeq: ownHorse?.last_seq ?? 0 });
-  const app = render4(React8.createElement(RunRace, { active, initialState: initial.initialState, pendingMode: initial.pendingMode, ownUserName: identity.display_name }));
+  const app = render4(React9.createElement(RunRace, { active, initialState: initial.initialState, pendingMode: initial.pendingMode, ownUserName: identity.display_name }));
   await app.waitUntilExit();
   return 0;
 }
 async function pickHorse(horses) {
   return new Promise((resolve) => {
     const app = render4(
-      React8.createElement(HorsePicker, {
+      React9.createElement(HorsePicker, {
         horses,
         onPick: (h) => {
           app.unmount();
@@ -1916,6 +2332,18 @@ async function pickHorse(horses) {
     );
   });
 }
+async function pickPrimary() {
+  return new Promise((resolve) => {
+    const app = render4(
+      React9.createElement(PrimaryPicker, {
+        onPick: (m) => {
+          app.unmount();
+          resolve(m);
+        }
+      })
+    );
+  });
+}
 
 // src/commands/end.ts
 import * as readline3 from "readline/promises";
@@ -2114,30 +2542,30 @@ function runNpmUpgrade(spawnImpl) {
 }
 
 // src/commands/roll.ts
-import React12 from "react";
+import React13 from "react";
 import { render as render5 } from "ink";
 
 // src/ui/RollReveal.tsx
-import { useState as useState6, useEffect as useEffect4, useMemo } from "react";
-import { Box as Box9, Text as Text9 } from "ink";
+import { useState as useState7, useEffect as useEffect4, useMemo } from "react";
+import { Box as Box10, Text as Text10 } from "ink";
 
 // src/ui/HatSprite.tsx
-import { useEffect as useEffect3, useState as useState5 } from "react";
-import { Box as Box8, Text as Text8 } from "ink";
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { useEffect as useEffect3, useState as useState6 } from "react";
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
 function HatSprite({ hat, variant, centerIn }) {
   const colors = hatColorsFor2(hat, variant ?? 0);
   const grid = makeHatGrid(hat, colors, centerIn);
   const lines = hexGridToHalfBlocks(grid);
-  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx8(Text8, { children: line }, i)) });
+  return /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx9(Text9, { children: line }, i)) });
 }
 function AnimatedHatSprite({ hat, variant, centerIn }) {
   if (hat.rarity !== "legendary") {
-    return /* @__PURE__ */ jsx8(HatSprite, { hat, variant, centerIn });
+    return /* @__PURE__ */ jsx9(HatSprite, { hat, variant, centerIn });
   }
   const frames = hat.animation.frames;
   const fps = hat.animation.fps;
-  const [idx, setIdx] = useState5(0);
+  const [idx, setIdx] = useState6(0);
   useEffect3(() => {
     if (frames.length <= 1) return;
     const interval = setInterval(
@@ -2147,7 +2575,7 @@ function AnimatedHatSprite({ hat, variant, centerIn }) {
     return () => clearInterval(interval);
   }, [frames.length, fps]);
   const framed = { ...hat, colors: { ...hat.colors, A: frames[idx] } };
-  return /* @__PURE__ */ jsx8(HatSprite, { hat: framed, variant, centerIn });
+  return /* @__PURE__ */ jsx9(HatSprite, { hat: framed, variant, centerIn });
 }
 function hatColorsFor2(hat, variantIdx) {
   if (hat.rarity === "legendary") return hat.colors;
@@ -2174,7 +2602,7 @@ function makeHatGrid(hat, colors, centerIn) {
 }
 
 // src/ui/RollReveal.tsx
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { jsx as jsx10 } from "react/jsx-runtime";
 var RESET3 = "\x1B[0m";
 var BOX_COLOR = "#E5C76B";
 var TIER_PALETTE = {
@@ -2243,7 +2671,7 @@ var BOX_EMPTY = [
   ""
 ].map(pad);
 function GiftBox({ frame, color }) {
-  return /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", children: frame.map((line, i) => /* @__PURE__ */ jsx9(Text9, { children: line ? ansiFg(color) + line + RESET3 : line }, i)) });
+  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: frame.map((line, i) => /* @__PURE__ */ jsx10(Text10, { children: line ? ansiFg(color) + line + RESET3 : line }, i)) });
 }
 function spawnParticles(tier, count, cx, cy) {
   const palette = TIER_PALETTE[tier];
@@ -2266,7 +2694,7 @@ function ConfettiBurst({ tier }) {
   const cx = Math.floor(SCENE_W / 2);
   const cy = Math.floor(SCENE_H / 2);
   const particles = useMemo(() => spawnParticles(tier, 36, cx, cy), [tier, cx, cy]);
-  const [tick, setTick] = useState6(0);
+  const [tick, setTick] = useState7(0);
   useEffect4(() => {
     const i = setInterval(() => setTick((t) => t + 1), 70);
     return () => clearInterval(i);
@@ -2279,13 +2707,13 @@ function ConfettiBurst({ tier }) {
       grid[y][x] = ansiFg(p.color) + p.char + RESET3;
     }
   }
-  return /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", children: grid.map((row, y) => /* @__PURE__ */ jsx9(Text9, { children: row.join("") }, y)) });
+  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: grid.map((row, y) => /* @__PURE__ */ jsx10(Text10, { children: row.join("") }, y)) });
 }
 var CLOSED_HOLD_MS = 3e3;
 function RollReveal({ outcome, onDone }) {
   const isNoHat = outcome.kind === "no_hat";
   const isLegendary = outcome.kind !== "no_hat" && outcome.hat.rarity === "legendary";
-  const [phase, setPhase] = useState6("closed");
+  const [phase, setPhase] = useState7("closed");
   useEffect4(() => {
     const timers = [];
     timers.push(setTimeout(() => setPhase("open1"), CLOSED_HOLD_MS));
@@ -2300,24 +2728,24 @@ function RollReveal({ outcome, onDone }) {
     }
     return () => timers.forEach(clearTimeout);
   }, [isNoHat, isLegendary, onDone]);
-  if (phase === "closed") return /* @__PURE__ */ jsx9(GiftBox, { frame: BOX_CLOSED, color: BOX_COLOR });
-  if (phase === "open1") return /* @__PURE__ */ jsx9(GiftBox, { frame: BOX_OPENING_1, color: BOX_COLOR });
-  if (phase === "open2") return /* @__PURE__ */ jsx9(GiftBox, { frame: BOX_OPENING_2, color: BOX_COLOR });
-  if (phase === "empty") return /* @__PURE__ */ jsx9(GiftBox, { frame: BOX_EMPTY, color: BOX_COLOR });
+  if (phase === "closed") return /* @__PURE__ */ jsx10(GiftBox, { frame: BOX_CLOSED, color: BOX_COLOR });
+  if (phase === "open1") return /* @__PURE__ */ jsx10(GiftBox, { frame: BOX_OPENING_1, color: BOX_COLOR });
+  if (phase === "open2") return /* @__PURE__ */ jsx10(GiftBox, { frame: BOX_OPENING_2, color: BOX_COLOR });
+  if (phase === "empty") return /* @__PURE__ */ jsx10(GiftBox, { frame: BOX_EMPTY, color: BOX_COLOR });
   if (phase === "burst" && outcome.kind !== "no_hat") {
-    return /* @__PURE__ */ jsx9(ConfettiBurst, { tier: outcome.hat.rarity });
+    return /* @__PURE__ */ jsx10(ConfettiBurst, { tier: outcome.hat.rarity });
   }
-  if (outcome.kind === "no_hat") return /* @__PURE__ */ jsx9(GiftBox, { frame: BOX_EMPTY, color: BOX_COLOR });
-  return outcome.hat.rarity === "legendary" ? /* @__PURE__ */ jsx9(AnimatedHatSprite, { hat: outcome.hat, centerIn: { w: SCENE_W, h: SCENE_H } }) : /* @__PURE__ */ jsx9(HatSprite, { hat: outcome.hat, variant: outcome.variant, centerIn: { w: SCENE_W, h: SCENE_H } });
+  if (outcome.kind === "no_hat") return /* @__PURE__ */ jsx10(GiftBox, { frame: BOX_EMPTY, color: BOX_COLOR });
+  return outcome.hat.rarity === "legendary" ? /* @__PURE__ */ jsx10(AnimatedHatSprite, { hat: outcome.hat, centerIn: { w: SCENE_W, h: SCENE_H } }) : /* @__PURE__ */ jsx10(HatSprite, { hat: outcome.hat, variant: outcome.variant, centerIn: { w: SCENE_W, h: SCENE_H } });
 }
 
 // src/ui/RollHorsePicker.tsx
-import { useState as useState7 } from "react";
-import { Box as Box10, Text as Text10, useInput as useInput3 } from "ink";
-import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+import { useState as useState8 } from "react";
+import { Box as Box11, Text as Text11, useInput as useInput4 } from "ink";
+import { jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
 function RollHorsePicker({ horses, onPick, onCancel }) {
-  const [idx, setIdx] = useState7(0);
-  useInput3((input, key) => {
+  const [idx, setIdx] = useState8(0);
+  useInput4((input, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -2336,33 +2764,33 @@ function RollHorsePicker({ horses, onPick, onCancel }) {
       return;
     }
   });
-  return /* @__PURE__ */ jsxs6(Box10, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx10(Text10, { children: "Pick a horse to roll for:" }),
-    horses.map((h, i) => /* @__PURE__ */ jsxs6(Box10, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx10(Box10, { flexDirection: "row", children: /* @__PURE__ */ jsxs6(Text10, { children: [
+  return /* @__PURE__ */ jsxs7(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Text11, { children: "Pick a horse to roll for:" }),
+    horses.map((h, i) => /* @__PURE__ */ jsxs7(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", children: /* @__PURE__ */ jsxs7(Text11, { children: [
         i === idx ? "\u25BA" : " ",
         " ",
         h.name,
         " ",
-        /* @__PURE__ */ jsxs6(Text10, { color: "cyan", children: [
+        /* @__PURE__ */ jsxs7(Text11, { color: "cyan", children: [
           "[Lvl. ",
           levelFromXp(h.xp),
           "]"
         ] }),
         " ",
-        /* @__PURE__ */ jsxs6(Text10, { color: "yellow", children: [
+        /* @__PURE__ */ jsxs7(Text11, { color: "yellow", children: [
           "\u2014 ",
           h.pending,
           " roll",
           h.pending === 1 ? "" : "s"
         ] })
       ] }) }),
-      /* @__PURE__ */ jsxs6(Box10, { flexDirection: "row", children: [
-        /* @__PURE__ */ jsx10(Text10, { children: "  " }),
-        /* @__PURE__ */ jsx10(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors })
+      /* @__PURE__ */ jsxs7(Box11, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx11(Text11, { children: "  " }),
+        /* @__PURE__ */ jsx11(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors })
       ] })
     ] }, h.stable_horse_id)),
-    /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: "\u2191/\u2193 choose \xB7 Enter pick \xB7 Esc cancel" }) })
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "\u2191/\u2193 choose \xB7 Enter pick \xB7 Esc cancel" }) })
   ] });
 }
 
@@ -2391,7 +2819,7 @@ function resetStdinAfterInk() {
 }
 async function runReveal(outcome) {
   await new Promise((resolve) => {
-    const app = render5(React12.createElement(RollReveal, {
+    const app = render5(React13.createElement(RollReveal, {
       outcome,
       onDone: () => {
         app.unmount();
@@ -2417,7 +2845,7 @@ async function rollCommand() {
     return 0;
   }
   const picked = await new Promise((resolve) => {
-    const app = render5(React12.createElement(RollHorsePicker, {
+    const app = render5(React13.createElement(RollHorsePicker, {
       horses: eligible,
       onPick: (h) => {
         app.unmount();
@@ -2682,7 +3110,7 @@ function flag(args, name) {
   }
   return void 0;
 }
-var USAGE = 'Usage: token-derby organisation schedule set <org-name> --days mon-fri --start 09:00 --end 17:30 --tz Europe/London [--name "Daily"] [--max 30] [--counts-input]';
+var USAGE = 'Usage: token-derby organisation schedule set <org-name> --days mon-fri --start 09:00 --end 17:30 --tz Europe/London [--name "Daily"] [--max 30] [--counts-input] [--primary-top5]';
 async function orgScheduleSetCommand(orgName, rest) {
   if (!orgName) {
     console.error(USAGE);
@@ -2695,6 +3123,7 @@ async function orgScheduleSetCommand(orgName, rest) {
   const name = flag(rest, "--name");
   const maxStr = flag(rest, "--max");
   const counts_input = rest.includes("--counts-input");
+  const primary_top5 = rest.includes("--primary-top5");
   if (!daysSpec || !start || !end || !tz) {
     console.error("Required flags: --days, --start, --end, --tz");
     console.error(USAGE);
@@ -2721,10 +3150,12 @@ async function orgScheduleSetCommand(orgName, rest) {
       tz,
       ...name ? { race_name: name } : {},
       ...max_participants !== void 0 ? { max_participants } : {},
-      ...counts_input ? { counts_input: true } : {}
+      ...counts_input ? { counts_input: true } : {},
+      ...primary_top5 ? { primary_top5: true } : {}
     });
     const s = resp.schedule;
     console.log(`Schedule set for ${orgName}: days [${s.weekdays.join(",")}] ${s.start_local}\u2013${s.end_local} ${s.tz}`);
+    if (s.primary_top5) console.log("  Primary score counts only each racer's top 5 conversations per beat.");
     return 0;
   } catch (e) {
     if (e instanceof ApiError) {
@@ -2746,6 +3177,7 @@ async function orgScheduleGetCommand(orgName) {
     if (resp.schedule) {
       const s = resp.schedule;
       console.log(`Schedule for ${orgName}: days [${s.weekdays.join(",")}] ${s.start_local}\u2013${s.end_local} ${s.tz}`);
+      if (s.primary_top5) console.log("  Primary top-5 conversations cap: ON.");
     } else {
       console.log(`No schedule configured for ${orgName}.`);
     }
@@ -2896,7 +3328,7 @@ async function main() {
     const orgName = parseFlag(argv.slice(1), "--organisation");
     return createRaceCommand(orgName);
   }
-  if (cmd === "join") return joinCommand(argv[1]);
+  if (cmd === "join") return joinCommand(argv[1], argv.slice(2));
   if (cmd === "end") return endCommand(argv[1]);
   if (cmd === "roll") return rollCommand();
   console.error(`Unknown command: ${cmd}`);