@mauricode/token-derby 3.1.2 → 4.0.0

package/dist/bin.js

@@ -16,7 +16,7 @@
  */
 
 // src/commands/stable-create.ts
-import React3 from "react";
+import React2 from "react";
 import { render } from "ink";
 
 // src/ui/HorseCreator.tsx
@@ -25,10 +25,9 @@ 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.5;
-function isModelKey(v) {
-  return typeof v === "string" && MODEL_KEYS.includes(v);
+var MODEL_FAMILIES = ["anthropic", "openai", "google"];
+function zeroPerFamily() {
+  return { anthropic: 0, openai: 0, google: 0 };
 }
 
 // ../shared/dist/constants.js
@@ -102,51 +101,22 @@ var ACHIEVEMENT_DESCRIPTIONS = {
   "Racer!": "Raced continuously for an hour",
   "Overtake!": "Overtook another horse",
   "Pacesetter!": "Led the race for an hour straight",
-  "Stampede!": "Gained 7,000+ tokens in a single minute",
+  "Stampede!": "Gained 70,000+ tokens in a single minute",
   "Took the lead!": "Charged into first place",
   "Comeback!": "Climbed from last place to the top half",
-  "Pulled Away!": "Grew the lead by 5,000+ tokens in a minute"
+  "Pulled Away!": "Grew the lead by 50,000+ tokens in a minute"
 };
 function overtakeDescription(positionsClimbed) {
   if (positionsClimbed <= 1)
     return "Overtook another horse";
   return `Overtook ${positionsClimbed} horses`;
 }
-var TOKEN_INPUT_MULTIPLIER = 10;
-function tokenMultiplier(race) {
-  return race.counts_input ? TOKEN_INPUT_MULTIPLIER : 1;
-}
-function describeAchievement(event, race) {
+function describeAchievement(event) {
   if (event.name === "Overtake!") {
     return overtakeDescription(Math.floor(event.xp / 3));
   }
-  const m = tokenMultiplier(race);
-  if (event.name === "Stampede!") {
-    return `Gained ${(MIDRACE_THRESHOLDS.stampede_tokens * m).toLocaleString("en-US")}+ tokens in a single minute`;
-  }
-  if (event.name === "Pulled Away!") {
-    return `Grew the lead by ${(MIDRACE_THRESHOLDS.pulled_away_gap * m).toLocaleString("en-US")}+ tokens in a minute`;
-  }
   return ACHIEVEMENT_DESCRIPTIONS[event.name];
 }
-var MIDRACE_THRESHOLDS = {
-  warm_up_fraction: 0.08,
-  // first 8% of race time
-  streak_hour_ms: 36e5,
-  // 1 hour for Racer!/Pacesetter!
-  racer_dt_cap_ms: 9e4,
-  // single-tick credit cap for Racer!
-  stampede_tokens: 7e3,
-  // tokens-in-a-minute threshold
-  stampede_cooldown_ms: 72e5,
-  // 2 hours
-  pulled_away_gap: 5e3,
-  // gap-growth threshold per minute
-  pulled_away_cooldown_ms: 72e5,
-  // 2 hours
-  recent_events_retention_ms: 9e4
-  // sliding window for recent_events
-};
 
 // ../shared/dist/hats.js
 function hatById(id) {
@@ -280,38 +250,132 @@ function toTag(c, y) {
   }
 }
 
+// ../shared/dist/scoring/modifiers/stamina.js
+var FULL_STAMINA = 100;
+var RECOVER_TICK_CAP_MS = 9e4;
+var STATE_KEY = "level";
+var PARAMS = {
+  sustainable_pace: {
+    label: "Sustainable pace (tokens/min)",
+    min: 1e4,
+    max: 2e5,
+    step: 2500,
+    default: 4e4
+  },
+  drain_per_min: {
+    label: "Drain rate (stamina/min above pace)",
+    min: 1,
+    max: 12,
+    step: 1,
+    default: 4
+  },
+  max_drain_per_min: {
+    label: "Max drain rate (stamina/min)",
+    min: 2,
+    max: 20,
+    step: 1,
+    default: 6
+  },
+  recover_per_min: {
+    label: "Recovery rate (stamina/min at or below pace)",
+    min: 1,
+    max: 8,
+    step: 1,
+    default: 2
+  },
+  taper_floor: {
+    label: "Taper floor (stamina %)",
+    min: 10,
+    max: 60,
+    step: 5,
+    default: 25
+  },
+  tired_multiplier: {
+    label: "Tired multiplier",
+    min: 0.2,
+    max: 0.9,
+    step: 0.05,
+    default: 0.5
+  }
+};
+var fmt = (n) => Intl.NumberFormat("en-US", { maximumFractionDigits: 2 }).format(n);
+var stamina = {
+  id: "stamina",
+  label: "Stamina",
+  description: "Horses running above a sustainable pace tire and score less until they recover.",
+  enabledByDefault: false,
+  params: PARAMS,
+  apply(ctx) {
+    const level = ctx.state[STATE_KEY] ?? FULL_STAMINA;
+    const minutes = ctx.dt_ms / 6e4;
+    if (minutes <= 0)
+      return { multiplier: 1, state: { [STATE_KEY]: level } };
+    const step = staminaStep({ level, pace: ctx.delta / minutes, minutes, params: ctx.params });
+    return { multiplier: step.multiplier, state: { [STATE_KEY]: step.level } };
+  },
+  preview(params) {
+    const p = params;
+    const drained = staminaStep({ level: FULL_STAMINA, pace: p.sustainable_pace * 2, minutes: 1, params: p });
+    const perMin = FULL_STAMINA - drained.level;
+    const spent = staminaStep({ level: 0, pace: 0, minutes: 1, params: p });
+    return [
+      { label: "Draining begins above", value: `${fmt(p.sustainable_pace)} tokens/min` },
+      { label: "At twice that pace, full stamina reaches the floor in", value: `${fmt((FULL_STAMINA - p.taper_floor) / perMin)} min` },
+      { label: "A fully spent horse scores at", value: `${fmt(spent.multiplier * 100)}%` },
+      { label: "Empty to full takes", value: `${fmt(FULL_STAMINA / spent.level)} min` }
+    ];
+  }
+};
+function staminaStep(input) {
+  const { level, pace, minutes, params } = input;
+  const multiplier = level >= params.taper_floor ? 1 : params.tired_multiplier + (1 - params.tired_multiplier) * (level / params.taper_floor);
+  let next = level;
+  if (pace > params.sustainable_pace) {
+    const perMin = Math.min((pace / params.sustainable_pace - 1) * params.drain_per_min, params.max_drain_per_min);
+    next -= perMin * minutes;
+  } else {
+    const credited = Math.min(minutes, RECOVER_TICK_CAP_MS / 6e4);
+    next += params.recover_per_min * credited;
+  }
+  return { multiplier, level: Math.max(0, Math.min(FULL_STAMINA, next)) };
+}
+
+// ../shared/dist/scoring/registry.js
+var MODIFIERS = {
+  stamina
+};
+var MODIFIER_IDS = Object.keys(MODIFIERS);
+
+// ../shared/dist/scoring/modifier.js
+function resolveParams(modifier, overrides = {}) {
+  const out = {};
+  for (const [key, bound] of Object.entries(modifier.params)) {
+    const value = overrides[key];
+    out[key] = typeof value === "number" && Number.isFinite(value) ? value : bound.default;
+  }
+  return out;
+}
+
 // ../shared/dist/scoring.js
+function settingFor(race, id) {
+  if (race.modifiers)
+    return race.modifiers[id];
+  if (id !== "stamina")
+    return void 0;
+  return race.stamina ? { enabled: true, params: race.stamina_config ?? {} } : { enabled: false };
+}
+function staminaOf(horse) {
+  return horse.modifier_states?.stamina?.[STATE_KEY] ?? FULL_STAMINA;
+}
 function scoredOf(horse) {
   return horse.scored_tokens ?? horse.current_tokens;
 }
-var STAMINA = {
-  SUSTAINABLE_PACE: 4e3,
-  DRAIN_PER_MIN: 4,
-  MAX_DRAIN_PER_MIN: 6,
-  RECOVER_PER_MIN: 2,
-  RECOVER_TICK_CAP_MS: 9e4,
-  TAPER_FLOOR: 25,
-  TIRED_MULTIPLIER: 0.5
-};
+function resolveModifierParams(race, id) {
+  return resolveParams(MODIFIERS[id], settingFor(race, id)?.params ?? {});
+}
 function resolveStaminaConfig(race) {
-  const c = race.stamina_config ?? {};
-  return {
-    sustainable_pace: c.sustainable_pace ?? STAMINA.SUSTAINABLE_PACE,
-    drain_per_min: c.drain_per_min ?? STAMINA.DRAIN_PER_MIN,
-    max_drain_per_min: c.max_drain_per_min ?? STAMINA.MAX_DRAIN_PER_MIN,
-    recover_per_min: c.recover_per_min ?? STAMINA.RECOVER_PER_MIN,
-    taper_floor: c.taper_floor ?? STAMINA.TAPER_FLOOR,
-    tired_multiplier: c.tired_multiplier ?? STAMINA.TIRED_MULTIPLIER
-  };
+  return resolveModifierParams(race, "stamina");
 }
-var STAMINA_PARAM_BOUNDS = {
-  sustainable_pace: { min: 1e3, max: 2e4, step: 250, default: STAMINA.SUSTAINABLE_PACE },
-  drain_per_min: { min: 1, max: 12, step: 1, default: STAMINA.DRAIN_PER_MIN },
-  max_drain_per_min: { min: 2, max: 20, step: 1, default: STAMINA.MAX_DRAIN_PER_MIN },
-  recover_per_min: { min: 1, max: 8, step: 1, default: STAMINA.RECOVER_PER_MIN },
-  taper_floor: { min: 10, max: 60, step: 5, default: STAMINA.TAPER_FLOOR },
-  tired_multiplier: { min: 0.2, max: 0.9, step: 0.05, default: STAMINA.TIRED_MULTIPLIER }
-};
 
 // ../shared/dist/devices.js
 var DEVICE_CODE_LENGTH = Math.ceil(SECRET_TOKEN_BYTES * 4 / 3);
@@ -857,13 +921,13 @@ function apiBase() {
 var HEARTBEAT_INTERVAL_MS = 6e4;
 var SCAN_TIMEOUT_MS = HEARTBEAT_INTERVAL_MS * 0.75;
 var HEARTBEAT_RETRY_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 15e3];
-var PRIMARY_SILENT_THRESHOLD = 10;
+var SILENT_THRESHOLD = 10;
 
 // src/version.ts
 import { createRequire } from "module";
 function readVersion() {
-  if ("3.1.2".length > 0) {
-    return "3.1.2";
+  if ("4.0.0".length > 0) {
+    return "4.0.0";
   }
   try {
     const req = createRequire(import.meta.url);
@@ -877,7 +941,6 @@ var CLI_VERSION = readVersion();
 
 // src/identity/identity.ts
 import { promises as fs } from "fs";
-import * as path3 from "path";
 
 // src/paths.ts
 import * as os2 from "os";
@@ -891,6 +954,9 @@ function homeDir() {
 function identityFile() {
   return path2.join(homeDir(), "identity.json");
 }
+function prefsFile() {
+  return path2.join(homeDir(), "prefs.json");
+}
 function activeRaceFile(joinCode) {
   return path2.join(homeDir(), "active-races", `${joinCode}.json`);
 }
@@ -910,6 +976,15 @@ function codexSessionsDir() {
 function geminiTmpDir() {
   return process.env.TOKEN_DERBY_GEMINI_DIR ?? path2.join(os2.homedir(), ".gemini", "tmp");
 }
+function piSessionsDir() {
+  return process.env.TOKEN_DERBY_PI_DIR ?? path2.join(os2.homedir(), ".pi", "agent", "sessions");
+}
+function logDir() {
+  return path2.join(homeDir(), "logs");
+}
+function logFile() {
+  return path2.join(logDir(), "token-derby.log");
+}
 
 // src/identity/identity.ts
 async function readIdentityFile() {
@@ -964,6 +1039,63 @@ function validateDisplayName(name) {
   return { ok: true, name: trimmed };
 }
 
+// src/log/logger.ts
+import * as fs2 from "fs";
+var SECRET_KEY = /token|secret|authorization|credential|password/i;
+function redact(fields) {
+  const out = {};
+  for (const [key, value] of Object.entries(fields)) {
+    out[key] = SECRET_KEY.test(key) ? "[redacted]" : value;
+  }
+  return out;
+}
+function formatLine(at, level, event, fields) {
+  const body = fields && Object.keys(fields).length > 0 ? ` ${JSON.stringify(redact(fields))}` : "";
+  return `${at.toISOString()} ${level.padEnd(5)} ${event}${body}
+`;
+}
+var MAX_BYTES = 2e6;
+var MAX_FILES = 5;
+var currentBytes = null;
+var disabled = false;
+function rotate() {
+  const base = logFile();
+  fs2.rmSync(`${base}.${MAX_FILES - 1}`, { force: true });
+  for (let i = MAX_FILES - 2; i >= 1; i--) {
+    if (fs2.existsSync(`${base}.${i}`)) fs2.renameSync(`${base}.${i}`, `${base}.${i + 1}`);
+  }
+  if (fs2.existsSync(base)) fs2.renameSync(base, `${base}.1`);
+  currentBytes = 0;
+}
+function write(level, event, fields) {
+  if (disabled) return;
+  try {
+    append(level, event, fields);
+  } catch {
+    disabled = true;
+  }
+}
+function append(level, event, fields) {
+  const line = formatLine(/* @__PURE__ */ new Date(), level, event, fields);
+  const bytes = Buffer.byteLength(line);
+  fs2.mkdirSync(logDir(), { recursive: true });
+  if (currentBytes === null) {
+    currentBytes = fs2.existsSync(logFile()) ? fs2.statSync(logFile()).size : 0;
+  }
+  if (currentBytes > 0 && currentBytes + bytes > MAX_BYTES) rotate();
+  fs2.appendFileSync(logFile(), line, "utf8");
+  currentBytes += bytes;
+}
+function logInfo(event, fields) {
+  write("INFO", event, fields);
+}
+function logWarn(event, fields) {
+  write("WARN", event, fields);
+}
+function logError(event, fields) {
+  write("ERROR", event, fields);
+}
+
 // src/api/client.ts
 var ApiError = class extends Error {
   constructor(code, message, status) {
@@ -975,6 +1107,10 @@ var ApiError = class extends Error {
   code;
   status;
 };
+var SECRET_SEGMENT = /^\/(claims|races\/admin)\/[^/]+/;
+function loggablePath(path9) {
+  return path9.replace(SECRET_SEGMENT, (match) => `${match.slice(0, match.lastIndexOf("/") + 1)}[redacted]`);
+}
 var identityCache = null;
 function getIdentity() {
   if (!identityCache) identityCache = loadIdentity();
@@ -995,6 +1131,9 @@ async function request(method, path9, body, horseAuthToken, fetchImpl = fetch, i
   }
   if (horseAuthToken) headers["authorization"] = `Bearer ${horseAuthToken}`;
   if (body !== void 0) headers["content-type"] = "application/json";
+  const safePath = loggablePath(path9);
+  logInfo("http.req", { method, path: safePath });
+  const startedAt2 = Date.now();
   let res;
   try {
     res = await fetchImpl(url, {
@@ -1003,8 +1142,10 @@ async function request(method, path9, body, horseAuthToken, fetchImpl = fetch, i
       body: body !== void 0 ? JSON.stringify(body) : void 0
     });
   } catch (e) {
+    logError("http.err", { method, path: safePath, ms: Date.now() - startedAt2, message: e?.message ?? "fetch failed" });
     throw new ApiError("NETWORK_ERROR", e?.message ?? "fetch failed", 0);
   }
+  logInfo("http.res", { method, path: safePath, status: res.status, ms: Date.now() - startedAt2 });
   const text = await res.text();
   const contentType = res.headers.get("content-type") ?? "";
   let parsed = null;
@@ -1021,6 +1162,14 @@ async function request(method, path9, body, horseAuthToken, fetchImpl = fetch, i
     }
     throw new ApiError("NETWORK_ERROR", `HTTP ${res.status}`, res.status);
   }
+  if (parsed === null) {
+    const got = contentType || "no content-type";
+    throw new ApiError(
+      "NETWORK_ERROR",
+      `Expected JSON from ${method} ${safePath} but the server returned ${got} (HTTP ${res.status}). The API may be unavailable or the request was rejected upstream.`,
+      res.status
+    );
+  }
   return parsed;
 }
 
@@ -1124,7 +1273,7 @@ function logoutDevice() {
 async function stableCreateCommand() {
   let exitCode = 0;
   const app = render(
-    React3.createElement(HorseCreator, {
+    React2.createElement(HorseCreator, {
       onSubmit: async (name, colors) => {
         try {
           await createStableHorse({ name, colors });
@@ -1156,7 +1305,7 @@ async function stableCreateCommand() {
 }
 
 // src/commands/stable-list.tsx
-import React4 from "react";
+import React3 from "react";
 import { render as render2, Box as Box4, Text as Text4 } from "ink";
 import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
 async function stableListCommand() {
@@ -1176,13 +1325,13 @@ async function stableListCommand() {
     return 0;
   }
   const app = render2(
-    React4.createElement(StableList, { horses })
+    React3.createElement(StableList, { horses })
   );
   await app.waitUntilExit();
   return 0;
 }
 function StableList({ horses }) {
-  React4.useEffect(() => {
+  React3.useEffect(() => {
     setImmediate(() => process.exit(0));
   }, []);
   return /* @__PURE__ */ jsxs2(Box4, { flexDirection: "column", children: [
@@ -1251,7 +1400,7 @@ async function stableDeleteCommand(name) {
 }
 
 // src/commands/stable-edit.ts
-import React6 from "react";
+import React4 from "react";
 import { render as render3 } from "ink";
 
 // src/ui/HorsePicker.tsx
@@ -1308,121 +1457,699 @@ function HorsePicker({ horses, onPick, onCancel, prompt = "Pick a horse to race:
   ] });
 }
 
-// src/commands/stable-edit.ts
-async function stableEditCommand(name) {
-  const horses = await fetchStable();
-  if (!horses) return 1;
-  const existing = await pickHorseToEdit(horses, name);
-  if (existing === "not_found") {
-    console.error(`No horse named "${name}" in your stable.`);
-    return 1;
-  }
-  if (existing === "empty") {
-    console.log("No horses in your stable. Run `token-derby stable create` to make one.");
-    return 0;
+// src/stable/prefs.ts
+import * as fs7 from "fs/promises";
+
+// src/tokens/harnesses/claude-code/index.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// src/tokens/source-root.ts
+var SourceRootMissing = class extends Error {
+  constructor(dir) {
+    super(`No history directory at ${dir}`);
+    this.dir = dir;
+    this.name = "SourceRootMissing";
   }
-  if (existing === "cancelled") {
-    console.log("Cancelled.");
-    return 1;
+  dir;
+};
+async function readRoot(dir, read) {
+  try {
+    return await read();
+  } catch (e) {
+    if (e?.code === "ENOENT") throw new SourceRootMissing(dir);
+    throw e;
   }
-  const initialEquipped = existing.equipped_hat ?? null;
-  let exitCode = 0;
-  const app = render3(
-    React6.createElement(HorseCreator, {
-      initialColors: existing.colors,
-      initialName: existing.name,
-      lockName: true,
-      initialLevel: levelFromXp(existing.xp),
-      hats: existing.hats,
-      initialEquipped,
-      onSubmit: async (_name, colors, hatChoice) => {
-        const colorsChanged = !sameColors(colors, existing.colors);
-        const hatChanged = hatChoice !== void 0 && hatChoice !== initialEquipped;
-        try {
-          if (colorsChanged) await updateStableHorse(existing.stable_horse_id, { colors });
-          if (hatChanged) await equipHat(existing.stable_horse_id, { hat_index: hatChoice });
-          app.unmount();
-          if (!colorsChanged && !hatChanged) {
-            console.log(`No changes for "${existing.name}".`);
-          } else {
-            const parts = [];
-            if (colorsChanged) parts.push("colors");
-            if (hatChanged) parts.push(hatChoice === null ? "hat unequipped" : "hat equipped");
-            console.log(`\u2713 Updated "${existing.name}" (${parts.join(", ")}).`);
-          }
-        } catch (e) {
-          app.unmount();
-          if (e instanceof ApiError) {
-            console.error(`Error: ${e.code} ${e.message}`);
-            exitCode = 1;
-            return;
-          }
-          throw e;
-        }
-      },
-      onCancel: () => {
-        app.unmount();
-        console.log("Cancelled.");
-        exitCode = 1;
+}
+
+// src/tokens/harnesses/harness.ts
+function incremental(fold, families, notices) {
+  return { mode: "incremental", fold, families, ...notices ? { notices } : {} };
+}
+function custom(read) {
+  return { mode: "custom", read };
+}
+function wholeFile(parse2) {
+  return { mode: "whole-file", parse: parse2 };
+}
+function constant(family) {
+  return (state) => ({ [family]: { input: state.input, output: state.output } });
+}
+
+// src/tokens/harnesses/claude-code/index.ts
+var MAX_PROJECT_DEPTH = 8;
+var TRANSCRIPT_EXT = ".jsonl";
+var CLAUDE_FOLD = {
+  empty: () => ({ input: 0, output: 0 }),
+  append: (acc, lines) => {
+    let { input, output, last } = acc;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
       }
-    })
-  );
-  await app.waitUntilExit();
-  return exitCode;
+      const usage = parsed?.message?.usage;
+      if (!usage) continue;
+      const id = parsed?.requestId ?? parsed?.message?.id ?? void 0;
+      if (id !== void 0 && id === last) continue;
+      last = id;
+      input += addNum(usage.input_tokens) + addNum(usage.cache_creation_input_tokens);
+      output += addNum(usage.output_tokens);
+    }
+    return last === void 0 ? { input, output } : { input, output, last };
+  }
+};
+function addNum(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function sameColors(a, b) {
-  return a.body === b.body && a.mane === b.mane && a.tail === b.tail && a.saddle === b.saddle;
+var claudeCode = {
+  id: "claude-code",
+  label: "Claude Code",
+  enabledByDefault: true,
+  // counted since before harnesses were configurable
+  overrideVar: "TOKEN_DERBY_CLAUDE_DIR",
+  hints: [
+    `If CLAUDE_CONFIG_DIR relocated your config, Token Derby follows it \u2014`,
+    `check it points at the config root, not the projects directory.`
+  ],
+  root: claudeProjectsDir,
+  counting: incremental(CLAUDE_FOLD, constant("anthropic")),
+  async discover(root) {
+    const entries = await readRoot(root, () => fs3.readdir(root, { withFileTypes: true }));
+    const out = [];
+    for (const entry of entries) {
+      if (!await isDirectory(entry, root)) continue;
+      await collect(path3.join(root, entry.name), MAX_PROJECT_DEPTH, out);
+    }
+    return out;
+  },
+  // A "conversation" is one top-level session: <project>/<session>. The main
+  // session transcript and everything nested under <session>/subagents/** roll
+  // up into the same id.
+  conversationId(file, root) {
+    const rel = path3.relative(root, file);
+    const [project, session] = rel.split(path3.sep);
+    if (project === void 0 || session === void 0) return rel.replace(/\.jsonl$/, "");
+    return `${project}/${session.replace(/\.jsonl$/, "")}`;
+  }
+};
+async function collect(dir, depth, out) {
+  if (depth <= 0) return;
+  const entries = await fs3.readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.name.endsWith(TRANSCRIPT_EXT)) {
+      out.push(path3.join(dir, entry.name));
+    } else if (depth > 1 && await isDirectory(entry, dir)) {
+      await collect(path3.join(dir, entry.name), depth - 1, out);
+    }
+  }
 }
-async function fetchStable() {
+async function isDirectory(entry, parent) {
+  if (entry.isDirectory()) return true;
+  if (!entry.isSymbolicLink()) return false;
+  return fs3.stat(path3.join(parent, entry.name)).then((st) => st.isDirectory()).catch(() => false);
+}
+
+// src/tokens/harnesses/codex-cli/index.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+var SESSION_DIRS = ["sessions", "archived_sessions"];
+var ROLLOUT_PREFIX = "rollout-";
+var ROLLOUT_EXT = ".jsonl";
+var CODEX_FOLD = {
+  empty: () => ({ input: 0, output: 0 }),
+  append: (acc, lines) => {
+    let usage = null;
+    for (const line of lines) {
+      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 acc;
+    return {
+      input: Math.max(0, num(usage.input_tokens) - num(usage.cached_input_tokens)),
+      output: num(usage.output_tokens)
+    };
+  }
+};
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+var codexCli = {
+  id: "codex-cli",
+  label: "Codex CLI",
+  enabledByDefault: true,
+  // counted since before harnesses were configurable
+  overrideVar: "TOKEN_DERBY_CODEX_DIR",
+  root: codexSessionsDir,
+  counting: incremental(CODEX_FOLD, constant("openai")),
+  async discover(root) {
+    await readRoot(root, () => fs4.stat(root));
+    const out = [];
+    for (const dir of SESSION_DIRS) out.push(...await collect2(path4.join(root, dir)));
+    return out;
+  },
+  /** One rollout file is one conversation. */
+  conversationId(file) {
+    return file;
+  }
+};
+async function collect2(dir) {
+  let entries;
   try {
-    const resp = await listStable();
-    return resp.horses;
+    entries = await fs4.readdir(dir, { withFileTypes: true });
   } catch (e) {
-    if (e instanceof ApiError) {
-      console.error(`Error: ${e.code} ${e.message}`);
-      return null;
-    }
+    if (e?.code === "ENOENT") return [];
     throw e;
   }
-}
-async function pickHorseToEdit(horses, name) {
-  if (name) {
-    const found = horses.find((h) => h.name === name);
-    return found ?? "not_found";
+  const out = [];
+  for (const entry of entries) {
+    const full = path4.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...await collect2(full));
+    else if (entry.name.startsWith(ROLLOUT_PREFIX) && entry.name.endsWith(ROLLOUT_EXT)) out.push(full);
   }
-  if (horses.length === 0) return "empty";
-  const picked = await new Promise((resolve) => {
-    const app = render3(
-      React6.createElement(HorsePicker, {
-        horses,
-        onPick: (h) => {
-          app.unmount();
-          resolve(h);
-        },
-        onCancel: () => {
-          app.unmount();
-          resolve(null);
-        }
-      })
-    );
-  });
-  return picked ?? "cancelled";
+  return out;
 }
 
-// src/commands/create.ts
-import * as readline2 from "readline/promises";
-import { stdin as stdin2, stdout as stdout2 } from "process";
-var DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
-async function createRaceCommand(organisationName) {
-  const rl = readline2.createInterface({ input: stdin2, output: stdout2 });
-  try {
-    const name = (await rl.question("Race name: ")).trim();
-    if (!name) {
-      console.error("Name required.");
-      return 1;
+// src/tokens/harnesses/gemini-cli/index.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+var CHATS_DIR = "chats";
+var CHAT_EXTS = [".json", ".jsonl"];
+function num2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+var geminiCli = {
+  id: "gemini-cli",
+  label: "Gemini CLI",
+  enabledByDefault: true,
+  // counted since before harnesses were configurable
+  overrideVar: "TOKEN_DERBY_GEMINI_DIR",
+  root: geminiTmpDir,
+  // Gemini chats are rewritten whole rather than appended to, so there is no
+  // offset to resume from — the cache gates on mtime+size and recomputes in full.
+  counting: wholeFile((raw, file) => ({ families: { google: sumRaw(file, raw) } })),
+  async discover(root) {
+    const entries = await readRoot(root, () => fs5.readdir(root));
+    const out = [];
+    for (const entry of entries) {
+      const chatsDir = path5.join(root, entry, CHATS_DIR);
+      let files;
+      try {
+        files = await fs5.readdir(chatsDir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (CHAT_EXTS.some((ext) => f.endsWith(ext))) out.push(path5.join(chatsDir, f));
+      }
     }
-    const startRaw = (await rl.question("Start time (ISO 8601, blank = now): ")).trim();
-    const start = startRaw ? startRaw : (/* @__PURE__ */ new Date()).toISOString();
+    return out;
+  },
+  /** One chat file is one conversation. */
+  conversationId(file) {
+    return file;
+  }
+};
+function sumRaw(file, raw) {
+  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/harnesses/pi/index.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+
+// src/tokens/pool.ts
+var SCAN_CONCURRENCY = 12;
+async function mapWithConcurrency(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (true) {
+      const i = next++;
+      if (i >= items.length) return;
+      out[i] = await fn(items[i], i);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+
+// src/tokens/harnesses/pi/entries.ts
+import { createHash } from "crypto";
+function num3(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function modelOf(provider, modelId) {
+  return typeof provider === "string" && typeof modelId === "string" && provider && modelId ? { provider, modelId } : null;
+}
+function fingerprint(entry, rawLine) {
+  if (typeof entry?.id === "string" && typeof entry?.timestamp === "string") {
+    const role = entry?.message?.role ?? "";
+    return [entry.id, entry.timestamp, entry.type ?? "", role].join("\0");
+  }
+  return createHash("sha256").update(rawLine).digest("base64url");
+}
+var PI_FOLD = {
+  empty: () => ({ isSession: false, modelByEntry: {}, events: [] }),
+  append: (acc, lines) => {
+    let isSession = acc.isSession;
+    const modelByEntry = { ...acc.modelByEntry };
+    const events = [...acc.events];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry?.type === "session") {
+        isSession = entry.version === 3;
+        continue;
+      }
+      if (!isSession) continue;
+      const inherited = typeof entry?.parentId === "string" ? modelByEntry[entry.parentId] ?? null : null;
+      let active = inherited;
+      if (entry?.type === "model_change") {
+        active = modelOf(entry.provider, entry.modelId);
+      } else if (entry?.type === "message" && entry.message?.role === "assistant") {
+        active = modelOf(entry.message.provider, entry.message.model) ?? inherited;
+      }
+      if (typeof entry?.id === "string") modelByEntry[entry.id] = active;
+      let usage = null;
+      let usageModel = active;
+      if (entry?.type === "message" && (entry.message?.role === "assistant" || entry.message?.role === "toolResult")) {
+        usage = entry.message.usage;
+      } else if ((entry?.type === "compaction" || entry?.type === "branch_summary") && entry.usage) {
+        usage = entry.usage;
+        if (entry.type === "branch_summary" && typeof entry.fromId === "string") {
+          usageModel = modelByEntry[entry.fromId] ?? active;
+        }
+      }
+      if (!usage) continue;
+      const input = num3(usage.input) + num3(usage.cacheWrite);
+      const output = num3(usage.output);
+      if (input > 0 || output > 0) {
+        events.push({ fingerprint: fingerprint(entry, line), model: usageModel, input, output });
+      }
+    }
+    return { isSession, modelByEntry, events };
+  }
+};
+
+// src/tokens/harnesses/pi/providers.ts
+var DIRECT = {
+  anthropic: "anthropic",
+  openai: "openai",
+  "azure-openai-responses": "openai",
+  google: "google"
+};
+var GATEWAYS = /* @__PURE__ */ new Set([
+  "amazon-bedrock",
+  "openrouter",
+  "cloudflare-ai-gateway",
+  "vercel-ai-gateway",
+  "radius"
+]);
+function resolveProvider(provider) {
+  const normalised = provider.trim().toLowerCase();
+  const family = DIRECT[normalised];
+  if (family) return { kind: "family", family };
+  if (GATEWAYS.has(normalised)) return { kind: "gateway", provider: normalised };
+  return { kind: "other", provider: normalised };
+}
+function describeUncounted(uncounted) {
+  const gateways = /* @__PURE__ */ new Set();
+  const others = /* @__PURE__ */ new Set();
+  for (const r of uncounted) {
+    if (r.kind === "gateway") gateways.add(r.provider);
+    else if (r.kind === "other") others.add(r.provider);
+  }
+  const lines = [];
+  if (gateways.size > 0) {
+    lines.push(
+      `Pi usage on ${[...gateways].sort().join(", ")} not counted \u2014 can serve models we score, but not yet identifiable.`
+    );
+  }
+  if (others.size > 0) {
+    lines.push(
+      `Pi usage on ${[...others].sort().join(", ")} not counted \u2014 not one of the model families we score.`
+    );
+  }
+  return lines;
+}
+
+// src/tokens/harnesses/pi/index.ts
+var SESSION_EXT = ".jsonl";
+var IGNORED_DIRS = /* @__PURE__ */ new Set(["subagent-artifacts"]);
+var pi = {
+  id: "pi",
+  label: "Pi",
+  // Off until asked for: Pi arrived after the others, and adding a harness must
+  // never start counting someone's history behind their back.
+  enabledByDefault: false,
+  overrideVar: "TOKEN_DERBY_PI_DIR",
+  root: piSessionsDir,
+  async discover(root) {
+    await readRoot(root, () => fs6.stat(root));
+    const out = [];
+    await collect3(root, out);
+    return out.sort();
+  },
+  // Unused for a whole-history harness: it groups its own conversations, since
+  // one session's work can be spread across a file and its clones.
+  conversationId(file) {
+    return file;
+  },
+  counting: custom(readAll)
+};
+async function collect3(dir, out) {
+  const entries = await fs6.readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    const full = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!IGNORED_DIRS.has(entry.name)) await collect3(full, out);
+    } else if (entry.isFile() && entry.name.endsWith(SESSION_EXT)) {
+      out.push(full);
+    }
+  }
+}
+async function readAll(cache, files, root) {
+  const states = await mapWithConcurrency(files, SCAN_CONCURRENCY, (f) => cache.readIncremental(f, PI_FOLD));
+  const byConversation = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const uncounted = [];
+  files.forEach((file, i) => {
+    const state = states[i];
+    if (!state.isSession) return;
+    const conversation = conversationOf(file, root);
+    for (const event of state.events) {
+      if (seen.has(event.fingerprint)) continue;
+      seen.add(event.fingerprint);
+      if (!event.model) continue;
+      const resolved = resolveProvider(event.model.provider);
+      if (resolved.kind !== "family") {
+        uncounted.push(resolved);
+        continue;
+      }
+      addTo(byConversation, conversation, resolved.family, event.input, event.output);
+    }
+  });
+  return { byConversation, notices: describeUncounted(uncounted) };
+}
+function addTo(byConversation, conversation, family, input, output) {
+  const families = byConversation.get(conversation) ?? {};
+  const totals = families[family] ?? { input: 0, output: 0 };
+  totals.input += input;
+  totals.output += output;
+  families[family] = totals;
+  byConversation.set(conversation, families);
+}
+function conversationOf(file, root) {
+  return path6.relative(root, file).replace(/\.jsonl$/, "");
+}
+
+// src/tokens/harnesses/registry.ts
+var HARNESSES = {
+  "claude-code": claudeCode,
+  "codex-cli": codexCli,
+  "gemini-cli": geminiCli,
+  pi
+};
+var HARNESS_KEYS = Object.keys(HARNESSES);
+
+// src/stable/prefs.ts
+async function loadPrefs() {
+  let raw;
+  try {
+    raw = await fs7.readFile(prefsFile(), "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+  const obj = parsed;
+  const id = obj.default_stable_horse_id;
+  const harnesses = readHarnessChoices(obj);
+  return {
+    ...typeof id === "string" && id !== "" ? { default_stable_horse_id: id } : {},
+    ...Object.keys(harnesses).length > 0 ? { harnesses } : {}
+  };
+}
+function readHarnessChoices(obj) {
+  const raw = obj.harnesses;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "boolean" && HARNESS_KEYS.includes(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function isHarnessEnabled(prefs, key) {
+  return prefs.harnesses?.[key] ?? HARNESSES[key].enabledByDefault;
+}
+function enabledHarnesses(prefs) {
+  return HARNESS_KEYS.filter((key) => isHarnessEnabled(prefs, key));
+}
+async function setHarnessEnabled(key, enabled) {
+  const raw = await loadRaw();
+  const stored = typeof raw.harnesses === "object" && raw.harnesses !== null && !Array.isArray(raw.harnesses) ? raw.harnesses : {};
+  await savePrefs({ harnesses: { ...stored, [key]: enabled } });
+}
+async function savePrefs(patch) {
+  const merged = { ...await loadRaw(), ...patch };
+  for (const [k, v] of Object.entries(merged)) {
+    if (v === void 0) delete merged[k];
+  }
+  await fs7.mkdir(homeDir(), { recursive: true });
+  await fs7.writeFile(prefsFile(), JSON.stringify(merged, null, 2) + "\n", "utf8");
+}
+async function loadRaw() {
+  try {
+    const parsed = JSON.parse(await fs7.readFile(prefsFile(), "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function setDefaultHorse(stableHorseId) {
+  await savePrefs({ default_stable_horse_id: stableHorseId });
+}
+async function clearDefaultHorse() {
+  await savePrefs({ default_stable_horse_id: void 0 });
+}
+
+// src/stable/resolve-horse.ts
+async function resolveHorse(horses, opts = {}) {
+  if (horses.length === 0) return { kind: "empty" };
+  if (opts.name !== void 0) {
+    const found = horses.find((h) => h.name === opts.name);
+    return found ? { kind: "resolved", horse: found, via: "flag" } : { kind: "not_found", name: opts.name };
+  }
+  if (opts.pick) return interactive() ? { kind: "pick" } : { kind: "no_tty" };
+  if (opts.autoSelect !== false) {
+    const { default_stable_horse_id } = await loadPrefs();
+    if (default_stable_horse_id !== void 0) {
+      const found = horses.find((h) => h.stable_horse_id === default_stable_horse_id);
+      if (found) return { kind: "resolved", horse: found, via: "default" };
+    }
+    if (horses.length === 1) return { kind: "resolved", horse: horses[0], via: "only" };
+  }
+  return interactive() ? { kind: "pick" } : { kind: "no_tty" };
+}
+function interactive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function describeHorse(horse) {
+  return `${horse.name} [Lvl. ${levelFromXp(horse.xp)}]`;
+}
+function noticeFor(choice) {
+  if (choice.via === "flag") return null;
+  const which = choice.via === "default" ? "your default horse" : "your only horse";
+  return `Using ${which}: ${describeHorse(choice.horse)}
+(--horse <name> to pick another, --pick to choose)`;
+}
+function noTtyMessage(command) {
+  return [
+    `\`${command}\` needs to know which horse, and this is not an interactive terminal.`,
+    "Pass --horse <name>, or set a default with `token-derby stable default <name>`."
+  ].join("\n");
+}
+
+// src/commands/stable-edit.ts
+async function stableEditCommand(name) {
+  if (!interactive()) {
+    console.error("`token-derby stable edit` needs an interactive terminal.");
+    return 1;
+  }
+  const horses = await fetchStable();
+  if (!horses) return 1;
+  const existing = await pickHorseToEdit(horses, name);
+  if (existing === "not_found") {
+    console.error(`No horse named "${name}" in your stable.`);
+    return 1;
+  }
+  if (existing === "empty") {
+    console.log("No horses in your stable. Run `token-derby stable create` to make one.");
+    return 0;
+  }
+  if (existing === "cancelled") {
+    console.log("Cancelled.");
+    return 1;
+  }
+  if (existing === "no_tty") {
+    console.error(noTtyMessage("token-derby stable edit"));
+    return 1;
+  }
+  const initialEquipped = existing.equipped_hat ?? null;
+  let exitCode = 0;
+  const app = render3(
+    React4.createElement(HorseCreator, {
+      initialColors: existing.colors,
+      initialName: existing.name,
+      lockName: true,
+      initialLevel: levelFromXp(existing.xp),
+      hats: existing.hats,
+      initialEquipped,
+      onSubmit: async (_name, colors, hatChoice) => {
+        const colorsChanged = !sameColors(colors, existing.colors);
+        const hatChanged = hatChoice !== void 0 && hatChoice !== initialEquipped;
+        try {
+          if (colorsChanged) await updateStableHorse(existing.stable_horse_id, { colors });
+          if (hatChanged) await equipHat(existing.stable_horse_id, { hat_index: hatChoice });
+          app.unmount();
+          if (!colorsChanged && !hatChanged) {
+            console.log(`No changes for "${existing.name}".`);
+          } else {
+            const parts = [];
+            if (colorsChanged) parts.push("colors");
+            if (hatChanged) parts.push(hatChoice === null ? "hat unequipped" : "hat equipped");
+            console.log(`\u2713 Updated "${existing.name}" (${parts.join(", ")}).`);
+          }
+        } catch (e) {
+          app.unmount();
+          if (e instanceof ApiError) {
+            console.error(`Error: ${e.code} ${e.message}`);
+            exitCode = 1;
+            return;
+          }
+          throw e;
+        }
+      },
+      onCancel: () => {
+        app.unmount();
+        console.log("Cancelled.");
+        exitCode = 1;
+      }
+    })
+  );
+  await app.waitUntilExit();
+  return exitCode;
+}
+function sameColors(a, b) {
+  return a.body === b.body && a.mane === b.mane && a.tail === b.tail && a.saddle === b.saddle;
+}
+async function fetchStable() {
+  try {
+    const resp = await listStable();
+    return resp.horses;
+  } catch (e) {
+    if (e instanceof ApiError) {
+      console.error(`Error: ${e.code} ${e.message}`);
+      return null;
+    }
+    throw e;
+  }
+}
+async function pickHorseToEdit(horses, name) {
+  const choice = await resolveHorse(horses, { name });
+  if (choice.kind === "empty") return "empty";
+  if (choice.kind === "not_found") return "not_found";
+  if (choice.kind === "no_tty") return "no_tty";
+  if (choice.kind === "resolved") {
+    const notice = noticeFor(choice);
+    if (notice) console.log(notice);
+    return choice.horse;
+  }
+  const picked = await new Promise((resolve) => {
+    const app = render3(
+      React4.createElement(HorsePicker, {
+        horses,
+        onPick: (h) => {
+          app.unmount();
+          resolve(h);
+        },
+        onCancel: () => {
+          app.unmount();
+          resolve(null);
+        }
+      })
+    );
+  });
+  return picked ?? "cancelled";
+}
+
+// src/commands/create.ts
+import * as readline2 from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+var DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+async function createRaceCommand(organisationName) {
+  const rl = readline2.createInterface({ input: stdin2, output: stdout2 });
+  try {
+    const name = (await rl.question("Race name: ")).trim();
+    if (!name) {
+      console.error("Name required.");
+      return 1;
+    }
+    const startRaw = (await rl.question("Start time (ISO 8601, blank = now): ")).trim();
+    const start = startRaw ? startRaw : (/* @__PURE__ */ new Date()).toISOString();
     if (!isIso(start)) {
       console.error("Invalid start time.");
       return 1;
@@ -1450,12 +2177,14 @@ async function createRaceCommand(organisationName) {
       console.error("Organisation name must be 1\u201312 alphanumeric characters.");
       return 1;
     }
-    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 staminaRaw = (await rl.question("Stamina \u2014 horses that run flat out tire and score less until they recover? [y/N]: ")).trim().toLowerCase();
-    const stamina = staminaRaw === "y" || staminaRaw === "yes";
+    const modifiers = [];
+    if (!org) {
+      for (const id of MODIFIER_IDS) {
+        const m = MODIFIERS[id];
+        const raw = (await rl.question(`${m.label} \u2014 ${m.description} [y/N]: `)).trim().toLowerCase();
+        if (raw === "y" || raw === "yes") modifiers.push(id);
+      }
+    }
     const resp = await createRace({
       name,
       start_time: start,
@@ -1463,9 +2192,7 @@ async function createRaceCommand(organisationName) {
       tz,
       ...max !== void 0 ? { max_participants: max } : {},
       ...org ? { organisation_name: org } : {},
-      ...counts_input ? { counts_input: true } : {},
-      ...primary_top5 ? { primary_top5: true } : {},
-      ...stamina ? { stamina: true } : {}
+      ...modifiers.length > 0 ? { modifiers } : {}
     });
     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");
@@ -1478,14 +2205,8 @@ async function createRaceCommand(organisationName) {
     if (org) {
       console.log(`  Restricted to organisation: ${org}`);
     }
-    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.");
-    }
-    if (stamina) {
-      console.log("  Stamina on \u2014 horses running above a sustainable pace will tire.");
+    for (const id of modifiers) {
+      console.log(`  ${MODIFIERS[id].label} on \u2014 ${MODIFIERS[id].description}`);
     }
     console.log(`  Share with participants:  token-derby join ${resp.join_code}`);
     return 0;
@@ -1506,37 +2227,28 @@ function isIso(s) {
 }
 
 // src/commands/join.ts
-import React9 from "react";
+import React5 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 50%)." }),
-    /* @__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/args.ts
+function parseFlag(args, flag) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === flag) return args[i + 1];
+    const eq = `${flag}=`;
+    if (args[i]?.startsWith(eq)) return args[i].slice(eq.length);
+  }
+  return void 0;
+}
+function hasFlag(args, flag) {
+  return args.some((a) => a === flag || a.startsWith(`${flag}=`));
 }
 
 // src/stable/active-race.ts
-import * as fs2 from "fs/promises";
-import * as path4 from "path";
+import * as fs8 from "fs/promises";
+import * as path7 from "path";
 async function saveActiveRace(active) {
-  await fs2.mkdir(activeRacesDir(), { recursive: true });
-  await fs2.writeFile(
+  await fs8.mkdir(activeRacesDir(), { recursive: true });
+  await fs8.writeFile(
     activeRaceFile(active.join_code),
     JSON.stringify(active, null, 2) + "\n",
     "utf8"
@@ -1544,29 +2256,30 @@ async function saveActiveRace(active) {
 }
 
 // src/runtime/run-race.tsx
-import { useEffect as useEffect2, useRef, useState as useState5 } from "react";
-import { Box as Box8, Text as Text8, useApp } from "ink";
+import { useEffect as useEffect2, useRef, useState as useState4 } from "react";
+import { Box as Box7, Text as Text7, useApp } from "ink";
 
 // src/ui/StatusScreen.tsx
-import { Box as Box7, Text as Text7 } from "ink";
-import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var MODEL_LABELS = { claude: "Claude", codex: "Codex", gemini: "Gemini" };
+import { Box as Box6, Text as Text6 } from "ink";
+import { Fragment as Fragment2, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 function ModelList(props) {
-  const { primaryModel } = props;
-  const secondaryTag = ` (${Math.round(SECONDARY_WEIGHT * 100)}%)`;
-  return /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs5(Text7, { children: [
-    "Models:  ",
-    MODEL_KEYS.map((m, i) => /* @__PURE__ */ jsxs5(Text7, { children: [
+  const off = new Set(props.disabled ?? []);
+  return /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text6, { children: [
+    "Counting:  ",
+    HARNESS_KEYS.map((key, i) => /* @__PURE__ */ jsxs4(Text6, { children: [
       i > 0 ? " \xB7 " : "",
-      MODEL_LABELS[m],
-      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: m === primaryModel ? " (primary)" : secondaryTag })
-    ] }, m))
+      off.has(key) ? /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
+        HARNESSES[key].label,
+        " (off)"
+      ] }) : HARNESSES[key].label
+    ] }, key)),
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "  (all count the same)" })
   ] }) });
 }
 function StatusScreen(props) {
-  const { race, ownHorseId, ownHorseName, ownColors, ownUserName, lastHeartbeatAgoSec, lastHeartbeatOk, stalled, stallReason, primarySilent, primarySourceDir, primaryModel } = props;
+  const { race, ownHorseId, ownHorseName, ownColors, ownUserName, lastHeartbeatAgoSec, lastHeartbeatOk, stalled, stallReason, sourcesSilent, degraded, notices, disabledHarnesses } = props;
   if (!race) {
-    return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", children: /* @__PURE__ */ jsx7(Text7, { children: "Joining race\u2026" }) });
+    return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: /* @__PURE__ */ jsx6(Text6, { children: "Joining race\u2026" }) });
   }
   const own = race.horses.find((h) => h.horse_id === ownHorseId);
   const leader = race.horses[0];
@@ -1592,36 +2305,36 @@ function StatusScreen(props) {
     },
     {
       label: "Last heartbeat:",
-      value: /* @__PURE__ */ jsxs5(Fragment2, { children: [
+      value: /* @__PURE__ */ jsxs4(Fragment2, { children: [
         lastHeartbeatAgoSec === null ? "\u2014" : `${lastHeartbeatAgoSec}s ago`,
         " ",
-        /* @__PURE__ */ jsx7(Text7, { color: lastHeartbeatOk ? "green" : "yellow", children: lastHeartbeatOk ? "\u2713" : "\u26A0" })
+        /* @__PURE__ */ jsx6(Text6, { color: lastHeartbeatOk ? "green" : "yellow", children: lastHeartbeatOk ? "\u2713" : "\u26A0" })
       ] })
     }
   ];
-  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs5(Text7, { children: [
+  return /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text6, { children: [
       "\u{1F3C7} TOKEN DERBY \u2500\u2500\u2500 ",
-      /* @__PURE__ */ jsx7(Text7, { bold: true, children: race.name }),
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: race.name }),
       " \u2500\u2500\u2500 status: ",
-      /* @__PURE__ */ jsx7(Text7, { color: statusColor(race.status), children: race.status })
+      /* @__PURE__ */ jsx6(Text6, { color: statusColor(race.status), children: race.status })
     ] }),
-    /* @__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: [
+    /* @__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: [
           "  ",
           ownHorseName,
           " ",
-          /* @__PURE__ */ jsxs5(Text7, { color: "cyan", children: [
+          /* @__PURE__ */ jsxs4(Text6, { color: "cyan", children: [
             "[Lvl. ",
             lvl.level,
             "]"
           ] })
         ] }),
-        /* @__PURE__ */ jsxs5(Text7, { children: [
+        /* @__PURE__ */ jsxs4(Text6, { children: [
           "  ",
-          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
+          /* @__PURE__ */ jsxs4(Text6, { dimColor: true, children: [
             "(",
             ownUserName,
             ")"
@@ -1629,30 +2342,39 @@ function StatusScreen(props) {
         ] })
       ] })
     ] }),
-    /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx7(StatLines, { rows }),
-      stalled && /* @__PURE__ */ jsxs5(Text7, { color: "yellow", children: [
+    /* @__PURE__ */ jsxs4(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx6(StatLines, { rows }),
+      stalled && /* @__PURE__ */ jsxs4(Text6, { color: "yellow", children: [
         "\u26A0 ",
         stallReason ?? "Can't read token usage",
         ". Your race continues."
       ] }),
-      !stalled && primarySilent && /* @__PURE__ */ jsxs5(Text7, { color: "yellow", children: [
-        "\u26A0 No ",
-        MODEL_LABELS[primaryModel ?? "claude"],
-        " transcripts in ",
-        PRIMARY_SILENT_THRESHOLD,
-        " beats",
-        primarySourceDir ? ` \u2014 nothing under ${primarySourceDir}` : "",
-        ". Your race continues, but your horse cannot move until they can be read."
+      !stalled && (degraded?.length ?? 0) > 0 && degraded.map((d) => /* @__PURE__ */ jsxs4(Text6, { color: "yellow", children: [
+        "\u26A0 ",
+        d.label,
+        " not counted this beat \u2014 ",
+        d.message,
+        ". Your other sources still count, and ",
+        d.label,
+        " catches up once it can be read."
+      ] }, d.harness)),
+      !stalled && (notices?.length ?? 0) > 0 && notices.map((n) => /* @__PURE__ */ jsxs4(Text6, { color: "yellow", children: [
+        "\u26A0 ",
+        n
+      ] }, n)),
+      !stalled && (degraded?.length ?? 0) === 0 && sourcesSilent && /* @__PURE__ */ jsxs4(Text6, { color: "yellow", children: [
+        "\u26A0 No transcripts from any coding agent in ",
+        SILENT_THRESHOLD,
+        " beats. Your race continues, but your horse cannot move until they can be read."
       ] })
     ] }),
-    primaryModel && /* @__PURE__ */ jsx7(ModelList, { primaryModel }),
-    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Press Ctrl+C to crash out of the race." }) })
+    /* @__PURE__ */ jsx6(ModelList, { disabled: disabledHarnesses }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "Press Ctrl+C to crash out of the race." }) })
   ] });
 }
 function StatLines(props) {
   const width = Math.max(...props.rows.map((r) => r.label.length)) + 1;
-  return /* @__PURE__ */ jsx7(Fragment2, { children: props.rows.map((r) => /* @__PURE__ */ jsxs5(Text7, { children: [
+  return /* @__PURE__ */ jsx6(Fragment2, { children: props.rows.map((r) => /* @__PURE__ */ jsxs4(Text6, { children: [
     r.label.padEnd(width),
     r.value
   ] }, r.label)) });
@@ -1674,17 +2396,17 @@ function bar(pct, width) {
   return "\u2593".repeat(filled) + "\u2591".repeat(width - filled);
 }
 function staminaLine(own, race) {
-  const stamina = own?.stamina ?? 100;
+  const stamina2 = staminaOf(own ?? {});
   const cfg = resolveStaminaConfig(race);
   const floor = cfg.taper_floor;
-  const band = stamina > 50 ? "green" : stamina >= floor ? "amber" : "red";
+  const band = stamina2 > 50 ? "green" : stamina2 >= floor ? "amber" : "red";
   const color = band === "green" ? "green" : band === "amber" ? "yellow" : "red";
-  const pct = Math.max(0, Math.min(1, stamina / 100));
-  const multiplier = band === "red" ? cfg.tired_multiplier + (1 - cfg.tired_multiplier) * (stamina / floor) : null;
+  const pct = Math.max(0, Math.min(1, stamina2 / 100));
+  const multiplier = band === "red" ? cfg.tired_multiplier + (1 - cfg.tired_multiplier) * (stamina2 / floor) : null;
   return {
     label: "Stamina:",
-    value: /* @__PURE__ */ jsxs5(Text7, { color, children: [
-      `${Math.round(stamina)}%  ${bar(pct, 20)}`,
+    value: /* @__PURE__ */ jsxs4(Text6, { color, children: [
+      `${Math.round(stamina2)}%  ${bar(pct, 20)}`,
       multiplier !== null ? `  \xD7${multiplier.toFixed(2)}` : ""
     ] })
   };
@@ -1709,6 +2431,7 @@ function runHeartbeatLoop(opts) {
   let stopped = false;
   let pending = null;
   const stop = () => {
+    if (!stopped) logInfo("beat.stop", { retry: retryIndex });
     stopped = true;
     if (timer) clearTimeout(timer);
     timer = null;
@@ -1721,9 +2444,16 @@ function runHeartbeatLoop(opts) {
   const tick = async () => {
     if (stopped) return;
     try {
-      if (!pending) pending = await opts.prepareBeat();
+      if (!pending) {
+        logInfo("beat.prepare.start");
+        const startedAt2 = Date.now();
+        pending = await opts.prepareBeat();
+        logInfo("beat.prepare.done", { seq: pending.seq, ms: Date.now() - startedAt2 });
+      }
       const snapshot = pending;
+      const sentAt = Date.now();
       const resp = await opts.sendBeat(snapshot);
+      logInfo("beat.send.ok", { seq: snapshot.seq, ms: Date.now() - sentAt, race_status: resp.race_status });
       pending = null;
       retryIndex = 0;
       opts.onSuccess(resp, snapshot);
@@ -1736,6 +2466,13 @@ function runHeartbeatLoop(opts) {
     } catch (err) {
       opts.onError(err);
       const delay = opts.retryDelaysMs[Math.min(retryIndex, opts.retryDelaysMs.length - 1)] ?? 1e3;
+      logError("beat.send.err", {
+        seq: pending?.seq,
+        code: err?.code,
+        message: err?.message ?? String(err),
+        retry: retryIndex,
+        next_ms: delay
+      });
       retryIndex += 1;
       schedule(delay);
     }
@@ -1743,30 +2480,13 @@ function runHeartbeatLoop(opts) {
   schedule(0);
 }
 
-// src/tokens/transcripts.ts
-import * as fs4 from "fs/promises";
-import * as path6 from "path";
-
-// src/tokens/pool.ts
-var SCAN_CONCURRENCY = 12;
-async function mapWithConcurrency(items, limit, fn) {
-  const out = new Array(items.length);
-  let next = 0;
-  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
-    while (true) {
-      const i = next++;
-      if (i >= items.length) return;
-      out[i] = await fn(items[i], i);
-    }
-  });
-  await Promise.all(workers);
-  return out;
-}
+// src/tokens/harnesses/engine.ts
+import * as fs10 from "fs/promises";
 
 // src/tokens/scan-cache.ts
-import * as fs3 from "fs/promises";
-import * as path5 from "path";
-var CACHE_VERSION = 1;
+import * as fs9 from "fs/promises";
+import * as path8 from "path";
+var CACHE_VERSION = 2;
 function isEntry(v) {
   const e = v;
   return !!e && typeof e.mtimeMs === "number" && typeof e.size === "number" && typeof e.offset === "number";
@@ -1802,7 +2522,7 @@ var ScanCache = class _ScanCache {
    * re-reading that line once the writer completes it.
    */
   async readIncremental(file, fold) {
-    const st = await fs3.stat(file);
+    const st = await fs9.stat(file);
     const prev = this.entries.get(file);
     this.touched.add(file);
     if (prev && prev.mtimeMs === st.mtimeMs && prev.size === st.size) return prev.value;
@@ -1819,11 +2539,11 @@ var ScanCache = class _ScanCache {
    * chats). Gated on mtime+size, recomputed in full whenever either moves.
    */
   async readWhenChanged(file, compute) {
-    const st = await fs3.stat(file);
+    const st = await fs9.stat(file);
     const prev = this.entries.get(file);
     this.touched.add(file);
     if (prev && prev.mtimeMs === st.mtimeMs && prev.size === st.size) return prev.value;
-    const value = await compute(await fs3.readFile(file, "utf8"));
+    const value = await compute(await fs9.readFile(file, "utf8"));
     this.entries.set(file, { mtimeMs: st.mtimeMs, size: st.size, offset: st.size, value });
     return value;
   }
@@ -1835,20 +2555,20 @@ var ScanCache = class _ScanCache {
     const target = cacheFile(this.source);
     const tmp = `${target}.tmp`;
     try {
-      await fs3.mkdir(path5.dirname(target), { recursive: true });
-      await fs3.writeFile(tmp, JSON.stringify({ version: CACHE_VERSION, files: Object.fromEntries(this.entries) }));
-      await fs3.rename(tmp, target);
+      await fs9.mkdir(path8.dirname(target), { recursive: true });
+      await fs9.writeFile(tmp, JSON.stringify({ version: CACHE_VERSION, files: Object.fromEntries(this.entries) }));
+      await fs9.rename(tmp, target);
     } catch {
     }
   }
 };
 function cacheFile(source) {
-  return path5.join(homeDir(), "scan-cache", `${source}.json`);
+  return path8.join(homeDir(), "scan-cache", `${source}.json`);
 }
 async function loadEntries(source) {
   let parsed;
   try {
-    parsed = JSON.parse(await fs3.readFile(cacheFile(source), "utf8"));
+    parsed = JSON.parse(await fs9.readFile(cacheFile(source), "utf8"));
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -1863,7 +2583,7 @@ async function loadEntries(source) {
 }
 async function readCompleteLines(file, start, end) {
   if (end <= start) return { lines: [], tail: null, consumedTo: start };
-  const fh = await fs3.open(file, "r");
+  const fh = await fs9.open(file, "r");
   try {
     const buf = Buffer.allocUnsafe(end - start);
     const { bytesRead } = await fh.read(buf, 0, end - start, start);
@@ -1878,269 +2598,67 @@ async function readCompleteLines(file, start, end) {
       tail: tail === "" ? null : tail,
       consumedTo: start + lastNl + 1
     };
-  } finally {
-    await fh.close();
-  }
-}
-
-// src/tokens/source-root.ts
-var SourceRootMissing = class extends Error {
-  constructor(dir) {
-    super(`No history directory at ${dir}`);
-    this.dir = dir;
-    this.name = "SourceRootMissing";
-  }
-  dir;
-};
-async function readRoot(dir, read) {
-  try {
-    return await read();
-  } catch (e) {
-    if (e?.code === "ENOENT") throw new SourceRootMissing(dir);
-    throw e;
-  }
-}
-
-// src/tokens/transcripts.ts
-var MAX_PROJECT_DEPTH = 8;
-function conversationId(file, root) {
-  const rel = path6.relative(root, file);
-  const [project, session] = rel.split(path6.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);
-  const cache = await ScanCache.open("claude");
-  const totals = await mapWithConcurrency(files, SCAN_CONCURRENCY, (f) => cache.readIncremental(f, CLAUDE_FOLD));
-  await cache.save();
-  const byConv = /* @__PURE__ */ new Map();
-  files.forEach((file, i) => {
-    const t = totals[i];
-    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 listJsonlFiles(root) {
-  const entries = await readEntries(root, true);
-  const out = [];
-  for (const entry of entries) {
-    if (!await isDirectory(entry, root)) continue;
-    await collectJsonl(path6.join(root, entry.name), MAX_PROJECT_DEPTH, out);
-  }
-  return out;
-}
-async function collectJsonl(dir, depth, out) {
-  if (depth <= 0) return;
-  for (const entry of await readEntries(dir, false)) {
-    if (entry.name.endsWith(".jsonl")) {
-      out.push(path6.join(dir, entry.name));
-    } else if (depth > 1 && await isDirectory(entry, dir)) {
-      await collectJsonl(path6.join(dir, entry.name), depth - 1, out);
-    }
-  }
-}
-async function readEntries(dir, failLoud) {
-  if (failLoud) return readRoot(dir, () => fs4.readdir(dir, { withFileTypes: true }));
-  return fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
-}
-async function isDirectory(entry, parent) {
-  if (entry.isDirectory()) return true;
-  if (!entry.isSymbolicLink()) return false;
-  return fs4.stat(path6.join(parent, entry.name)).then((st) => st.isDirectory()).catch(() => false);
-}
-function addNum(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
-var CLAUDE_FOLD = {
-  empty: () => ({ input: 0, output: 0 }),
-  append: (acc, lines) => {
-    let { input, output } = acc;
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      let parsed;
-      try {
-        parsed = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const usage = parsed?.message?.usage;
-      if (!usage) continue;
-      input += addNum(usage.input_tokens) + addNum(usage.cache_creation_input_tokens);
-      output += addNum(usage.output_tokens);
-    }
-    return { input, output };
-  }
-};
-
-// src/tokens/codex.ts
-import * as fs5 from "fs/promises";
-import * as path7 from "path";
-function num(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
-}
-async function sumCodexByConversation() {
-  const root = codexSessionsDir();
-  await readRoot(root, () => fs5.stat(root));
-  const files = await listCodexRollouts(root);
-  const cache = await ScanCache.open("codex");
-  const totals = await mapWithConcurrency(
-    files,
-    SCAN_CONCURRENCY,
-    (f) => cache.readIncremental(f, CODEX_FOLD).catch(() => ({ input: 0, output: 0 }))
-  );
-  await cache.save();
-  const byConv = /* @__PURE__ */ new Map();
-  files.forEach((file, i) => byConv.set(file, totals[i]));
-  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 listCodexRollouts(root) {
-  return [
-    ...await collectRollouts(path7.join(root, "sessions")),
-    ...await collectRollouts(path7.join(root, "archived_sessions"))
-  ];
-}
-async function collectRollouts(dir) {
-  let entries;
-  try {
-    entries = await fs5.readdir(dir, { withFileTypes: true });
-  } catch (e) {
-    if (e?.code === "ENOENT") return [];
-    throw e;
-  }
-  const out = [];
-  for (const entry of entries) {
-    const full = path7.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;
-}
-var CODEX_FOLD = {
-  empty: () => ({ input: 0, output: 0 }),
-  append: (acc, lines) => {
-    let usage = null;
-    for (const line of lines) {
-      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 acc;
-    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 fs6 from "fs/promises";
-import * as path8 from "path";
-function num2(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
-}
-async function sumGeminiByConversation() {
-  const files = await listChatFiles(geminiTmpDir());
-  const cache = await ScanCache.open("gemini");
-  const totals = await mapWithConcurrency(
-    files,
-    SCAN_CONCURRENCY,
-    (f) => cache.readWhenChanged(f, async (raw) => sumGeminiRaw(f, raw)).catch(() => ({ input: 0, output: 0 }))
-  );
-  await cache.save();
-  const byConv = /* @__PURE__ */ new Map();
-  files.forEach((file, i) => byConv.set(file, totals[i]));
-  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 readRoot(root, () => fs6.readdir(root));
-  const out = [];
-  for (const entry of entries) {
-    const chatsDir = path8.join(root, entry, "chats");
-    let files;
-    try {
-      files = await fs6.readdir(chatsDir);
-    } catch {
-      continue;
-    }
-    for (const f of files) {
-      if (f.endsWith(".json") || f.endsWith(".jsonl")) out.push(path8.join(chatsDir, f));
-    }
-  }
-  return out;
-}
-function sumGeminiRaw(file, raw) {
-  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 [];
+  } finally {
+    await fh.close();
   }
 }
-function parseJsonl(raw) {
-  const out = [];
-  for (const line of raw.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      out.push(JSON.parse(line));
-    } catch {
+
+// src/tokens/harnesses/engine.ts
+async function readFile4(harness, cache, file) {
+  const counting = harness.counting;
+  if (counting.mode === "custom") throw new Error("custom counting is read whole-history, not per file");
+  if (counting.mode === "whole-file") {
+    return cache.readWhenChanged(file, async (raw) => counting.parse(raw, file));
+  }
+  const state = await cache.readIncremental(file, counting.fold);
+  const notices = counting.notices?.(state) ?? [];
+  return { families: counting.families(state), ...notices.length > 0 ? { notices } : {} };
+}
+async function count(harness) {
+  const root = harness.root();
+  const files = await harness.discover(root);
+  const cache = await ScanCache.open(harness.id);
+  const byFamily = /* @__PURE__ */ new Map();
+  const notices = /* @__PURE__ */ new Set();
+  const add = (id, families) => {
+    const prefixed = `${harness.id}:${id}`;
+    for (const [family, totals] of Object.entries(families)) {
+      if (!totals) continue;
+      const conversations = byFamily.get(family) ?? /* @__PURE__ */ new Map();
+      const acc = conversations.get(prefixed) ?? { input: 0, output: 0 };
+      acc.input += totals.input;
+      acc.output += totals.output;
+      conversations.set(prefixed, acc);
+      byFamily.set(family, conversations);
     }
-  }
-  return out;
+  };
+  if (harness.counting.mode === "custom") {
+    const reading = await harness.counting.read(cache, files, root);
+    await cache.save();
+    for (const notice of reading.notices ?? []) notices.add(notice);
+    for (const [id, families] of reading.byConversation) add(id, families);
+    return { byFamily, notices: [...notices] };
+  }
+  const readings = await mapWithConcurrency(files, SCAN_CONCURRENCY, (f) => readFile4(harness, cache, f));
+  await cache.save();
+  files.forEach((file, i) => {
+    const reading = readings[i];
+    for (const notice of reading.notices ?? []) notices.add(notice);
+    add(harness.conversationId(file, root), reading.families);
+  });
+  return { byFamily, notices: [...notices] };
+}
+async function probe(harness) {
+  const dir = harness.root();
+  const exists = await fs10.stat(dir).then((st) => st.isDirectory()).catch(() => false);
+  if (!exists) return { harness, dir, exists: false, projects: 0, transcripts: 0 };
+  const entries = await fs10.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const projects = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).length;
+  const files = await harness.discover(dir).catch((e) => {
+    if (e instanceof SourceRootMissing) return [];
+    return [];
+  });
+  return { harness, dir, exists: true, projects, transcripts: files.length };
 }
 
 // src/tokens/race-tokens.ts
@@ -2153,60 +2671,70 @@ async function scanWithTimeout(scan, timeoutMs, describeTimeout) {
   const budget = new Promise((resolve) => {
     timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
   });
+  const startedAt2 = Date.now();
   try {
     const result = await Promise.race([scan(), budget]);
-    if (result !== TIMED_OUT) return result;
+    if (result !== TIMED_OUT) {
+      if (isStall(result)) logWarn("scan.stall", { reason: result.stall, ms: Date.now() - startedAt2 });
+      return result;
+    }
     const detail = describeTimeout ? await describeTimeout() : null;
-    return { stall: detail ?? `Token scan timed out after ${Math.round(timeoutMs / 1e3)}s` };
+    const stall = detail ?? `Token scan timed out after ${Math.round(timeoutMs / 1e3)}s`;
+    logWarn("scan.timeout", { budget_ms: timeoutMs, reason: stall });
+    return { stall };
+  } catch (err) {
+    logError("scan.error", {
+      message: err?.message ?? String(err),
+      stack: err?.stack,
+      ms: Date.now() - startedAt2
+    });
+    throw err;
   } finally {
     clearTimeout(timer);
   }
 }
-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, progress) {
-  progress?.begin(primary);
-  const primaryScan = BY_CONVERSATION_READERS[primary]().then(
-    (map) => ({ ok: true, map }),
-    (err) => ({ ok: false, err })
-  ).finally(() => progress?.end(primary));
-  const secondaryKeys = MODEL_KEYS.filter((k) => k !== primary);
-  const secondaryScans = secondaryKeys.map((k) => {
-    progress?.begin(k);
-    return SCALAR_READERS[k]().then((t) => scoreFor(race, t)).catch(() => 0).finally(() => progress?.end(k));
-  });
-  const [primaryResult, secondaryValues] = await Promise.all([
-    primaryScan,
-    Promise.all(secondaryScans)
-  ]);
-  const primaryByConv = /* @__PURE__ */ new Map();
-  if (primaryResult.ok) {
-    for (const [id, totals] of primaryResult.map) primaryByConv.set(id, scoreFor(race, totals));
-  } else if (!(primaryResult.err instanceof SourceRootMissing)) {
-    const err = primaryResult.err;
-    return { stall: `Can't read ${primary} token usage: ${err?.message ?? String(err)}` };
-  }
-  const secondary = { claude: 0, codex: 0, gemini: 0 };
-  secondaryKeys.forEach((k, i) => {
-    secondary[k] = secondaryValues[i] ?? 0;
+function emptyByFamily() {
+  return { anthropic: /* @__PURE__ */ new Map(), openai: /* @__PURE__ */ new Map(), google: /* @__PURE__ */ new Map() };
+}
+function scoreFor(t) {
+  return t.input + t.output;
+}
+async function readAllSources(progress) {
+  const enabled = enabledHarnesses(await loadPrefs());
+  const scans = enabled.map((key) => {
+    progress?.begin(key);
+    return count(HARNESSES[key]).then((result) => ({ ok: true, key, result })).catch((err) => ({ ok: false, key, err })).finally(() => progress?.end(key));
   });
-  return { secondary, primaryByConv };
+  const results = await Promise.all(scans);
+  const byFamily = emptyByFamily();
+  const degraded = [];
+  const notices = /* @__PURE__ */ new Set();
+  for (const outcome of results) {
+    const harness = HARNESSES[outcome.key];
+    if (!outcome.ok) {
+      if (outcome.err instanceof SourceRootMissing) continue;
+      const message = outcome.err?.message ?? String(outcome.err);
+      logWarn("scan.source.err", { harness: outcome.key, message });
+      degraded.push({ harness: outcome.key, label: harness.label, message });
+      continue;
+    }
+    mergeInto(byFamily, outcome.result);
+    for (const notice of outcome.result.notices) notices.add(notice);
+  }
+  return { byFamily, degraded, notices: [...notices] };
+}
+function mergeInto(byFamily, result) {
+  for (const family of MODEL_FAMILIES) {
+    const conversations = result.byFamily.get(family);
+    if (!conversations) continue;
+    const target = byFamily[family];
+    for (const [id, totals] of conversations) target.set(id, scoreFor(totals));
+  }
 }
 
 // src/tokens/scan-progress.ts
 function skipVar(key) {
-  return `TOKEN_DERBY_${key.toUpperCase()}_DIR`;
+  return HARNESSES[key].overrideVar;
 }
 function formatBytes(bytes) {
   if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
@@ -2240,45 +2768,30 @@ async function diagnoseScanTimeout(timeoutMs, progress) {
   return describeScanTimeout(timeoutMs, outstanding);
 }
 
-// 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 };
+function cloneAnchors(a) {
+  return { anthropic: { ...a.anthropic }, openai: { ...a.openai }, google: { ...a.google } };
 }
 var RaceScoreTracker = class {
-  acked;
-  lastGood;
-  primaryConvAcked;
-  primaryConvLast;
+  convAcked;
+  convLast;
   counted;
   seq;
   stalls = 0;
   lastStall = null;
-  primaryEmptyBeats = 0;
-  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;
+  emptyBeats = 0;
+  constructor(init) {
+    this.convAcked = cloneAnchors(init.convAcked);
+    this.convLast = cloneAnchors(init.convAcked);
+    this.counted = { ...init.counted };
     this.seq = init.seq;
-    this.primary = primary;
-    this.primaryTop5 = primaryTop5;
   }
   /**
    * Record a scan result.
    * - `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).
+   * - otherwise → every model's per-conversation readings advance (monotonic).
    */
   recordReading(reading) {
     if (reading === null || isStall(reading)) {
@@ -2288,181 +2801,91 @@ var RaceScoreTracker = class {
     }
     this.stalls = 0;
     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;
-    }
-    this.primaryEmptyBeats = reading.primaryByConv.size === 0 ? this.primaryEmptyBeats + 1 : 0;
-    for (const [id, v] of reading.primaryByConv) {
-      const prev = this.primaryConvLast[id] ?? 0;
-      if (v > prev) this.primaryConvLast[id] = v;
+    const anyConversations = MODEL_FAMILIES.some((family) => reading.byFamily[family].size > 0);
+    this.emptyBeats = anyConversations ? 0 : this.emptyBeats + 1;
+    for (const family of MODEL_FAMILIES) {
+      for (const [id, value] of reading.byFamily[family]) {
+        const prev = this.convLast[family][id] ?? 0;
+        if (value > prev) this.convLast[family][id] = value;
+      }
     }
   }
   /** Frozen payload for the next heartbeat. Pure — call repeatedly for retries. */
   nextBeat() {
-    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);
+    const components = zeroPerFamily();
+    for (const family of MODEL_FAMILIES) {
+      let sum = 0;
+      for (const [id, last] of Object.entries(this.convLast[family])) {
+        sum += Math.max(0, last - (this.convAcked[family][id] ?? 0));
+      }
+      components[family] = sum;
     }
-    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 }
+      convReadings: cloneAnchors(this.convLast)
     };
   }
   /** Commit a heartbeat the server accepted. `serverLastSeq` self-heals drift. */
   ack(snapshot, serverLastSeq) {
-    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.convAcked = cloneAnchors(snapshot.convReadings);
+    for (const family of MODEL_FAMILIES) this.counted[family] += snapshot.components[family];
     this.seq = Math.max(snapshot.seq, serverLastSeq);
   }
   /** Pin anchors to the latest readings so the next deltas are 0 (pending race). */
   reprime() {
-    for (const key of MODEL_KEYS) {
-      if (key === this.primary) continue;
-      this.acked[key] = this.lastGood[key];
-    }
-    this.primaryConvAcked = { ...this.primaryConvLast };
+    this.convAcked = cloneAnchors(this.convLast);
   }
   get stalled() {
     return this.stalls >= STALL_THRESHOLD;
   }
-  /** The primary source has produced no conversations for long enough to be worth saying. */
-  get primarySilent() {
-    return this.primaryEmptyBeats >= PRIMARY_SILENT_THRESHOLD;
+  /** No source has produced any conversations for long enough to be worth saying. */
+  get sourcesSilent() {
+    return this.emptyBeats >= SILENT_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;
+  /** Cumulative tokens credited per family since joining (for the UI's model rows). */
+  countedPerFamily() {
+    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;
+  /** Cumulative tokens credited across every family. */
+  countedTotal() {
+    let total = 0;
+    for (const family of MODEL_FAMILIES) total += this.counted[family];
+    return total;
   }
   toState() {
     return {
-      acked: { ...this.acked },
-      lastGood: { ...this.lastGood },
-      primaryConvAcked: { ...this.primaryConvAcked },
-      primaryCounted: this.counted,
+      convAcked: cloneAnchors(this.convAcked),
+      counted: { ...this.counted },
       seq: this.seq
     };
   }
 };
 
-// src/tokens/source-probe.ts
-import * as fs7 from "fs/promises";
-var ROOTS = {
-  claude: claudeProjectsDir,
-  codex: codexSessionsDir,
-  gemini: geminiTmpDir
-};
-var LISTERS = {
-  claude: listJsonlFiles,
-  codex: listCodexRollouts,
-  gemini: listChatFiles
-};
-var LABELS2 = { claude: "Claude", codex: "Codex", gemini: "Gemini" };
-function sourceDir(key) {
-  return ROOTS[key]();
-}
-async function probeSource(key) {
-  const dir = ROOTS[key]();
-  const exists = await fs7.stat(dir).then((st) => st.isDirectory()).catch(() => false);
-  if (!exists) return { key, dir, exists: false, projects: 0, transcripts: 0 };
-  const entries = await fs7.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const projects = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).length;
-  const files = await LISTERS[key](dir).catch(() => []);
-  return { key, dir, exists: true, projects, transcripts: files.length };
-}
-function overrideVar(key) {
-  return `TOKEN_DERBY_${key.toUpperCase()}_DIR`;
-}
-async function confirmEmptySource(opts) {
-  if (opts.probe.transcripts > 0) return true;
-  opts.warn(describeEmptySource(opts.probe));
-  if (!opts.interactive) return true;
-  return opts.ask();
-}
-function describeEmptySource(probe) {
-  const label = LABELS2[probe.key];
-  const populated = probe.exists && probe.projects > 0;
-  const reason = !probe.exists ? "does not exist" : populated ? `holds ${probe.projects} project ${probe.projects === 1 ? "directory" : "directories"}, none of which could be read` : "exists, but holds no transcripts";
-  const lines = [
-    `\u26A0 No ${label} transcripts found \u2014 your horse will not move.`,
-    ``,
-    `  Looked in: ${probe.dir}`,
-    `             (${reason})`,
-    ``
-  ];
-  if (populated) {
-    lines.push(
-      `  The directory is there and has history in it, so this is usually a`,
-      `  dangling symlink or a permissions problem on one of those projects.`,
-      `  To find dangling links:`,
-      `    find ${probe.dir} -type l ! -exec test -e {} \\; -print`,
-      ``
-    );
-  }
-  lines.push(
-    `  Token Derby counts ${label} usage from this machine's own filesystem.`,
-    `  If ${label} runs in a container, over SSH, or on another machine, join`,
-    `  the race from there instead.`
-  );
-  if (probe.key === "claude") {
-    lines.push(
-      `  If CLAUDE_CONFIG_DIR relocated your config, Token Derby follows it \u2014`,
-      `  check it points at the config root, not the projects directory.`
-    );
-  }
-  lines.push(``, `  To read them from somewhere else: export ${overrideVar(probe.key)}=<dir>`);
-  return lines.join("\n");
-}
-
 // src/runtime/run-race.tsx
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function RunRace({ active, initialState, pendingMode, ownUserName }) {
   const { exit } = useApp();
-  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 [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 shownAchievementAtRef = useRef(0);
-  const trackerRef = useRef(new RaceScoreTracker(initialState, active.primary_model, active.primary_top5 ?? false));
+  const trackerRef = useRef(new RaceScoreTracker(initialState));
   const pendingRef = useRef(pendingMode);
   const ctrl = useRef(new AbortController());
-  const [stalled, setStalled] = useState5(false);
-  const [stallReason, setStallReason] = useState5(null);
-  const [primarySilent, setPrimarySilent] = useState5(false);
+  const [stalled, setStalled] = useState4(false);
+  const [stallReason, setStallReason] = useState4(null);
+  const [sourcesSilent, setSourcesSilent] = useState4(false);
+  const [degraded, setDegraded] = useState4([]);
+  const [notices, setNotices] = useState4([]);
+  const [disabledHarnesses, setDisabledHarnesses] = useState4([]);
   useEffect2(() => {
     const t = setInterval(() => setTickNow(/* @__PURE__ */ new Date()), 1e3);
     return () => clearInterval(t);
@@ -2479,7 +2902,7 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
       const progress = new ScanProgress();
       try {
         return await scanWithTimeout(
-          () => readAllSources(active, active.primary_model, progress),
+          () => readAllSources(progress),
           SCAN_TIMEOUT_MS,
           () => diagnoseScanTimeout(SCAN_TIMEOUT_MS, progress)
         );
@@ -2494,7 +2917,11 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
         if (pendingRef.current && !isStall(reading)) tracker.reprime();
         setStalled(tracker.stalled);
         setStallReason(tracker.stalled ? tracker.stallReason : null);
-        setPrimarySilent(tracker.primarySilent);
+        setSourcesSilent(tracker.sourcesSilent);
+        setDegraded(isStall(reading) ? [] : reading.degraded);
+        setNotices(isStall(reading) ? [] : reading.notices);
+        const prefs = await loadPrefs();
+        setDisabledHarnesses(HARNESS_KEYS.filter((k) => !isHarnessEnabled(prefs, k)));
         return tracker.nextBeat();
       },
       sendBeat: async (snapshot) => {
@@ -2544,13 +2971,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__ */ 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", 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", children: [
-    /* @__PURE__ */ jsx8(
+  return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(
       StatusScreen,
       {
         race,
@@ -2562,28 +2989,29 @@ function RunRace({ active, initialState, pendingMode, ownUserName }) {
         lastHeartbeatOk: lastHbOk,
         stalled,
         stallReason,
-        primarySilent,
-        primarySourceDir: sourceDir(active.primary_model),
-        primaryModel: active.primary_model
+        sourcesSilent,
+        degraded,
+        notices,
+        disabledHarnesses
       }
     ),
-    achievements.length > 0 && /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "Achievements" }),
+    achievements.length > 0 && /* @__PURE__ */ jsxs5(Box7, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Achievements" }),
       achievements.map(({ key, event }) => {
-        const description = describeAchievement(event, active);
-        return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "row", children: [
-          /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
+        const description = describeAchievement(event);
+        return /* @__PURE__ */ jsxs5(Box7, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "  ",
             formatClockTime(event.at),
             "  "
           ] }),
-          /* @__PURE__ */ jsxs6(Text8, { color: "yellow", bold: true, children: [
+          /* @__PURE__ */ jsxs5(Text7, { color: "yellow", bold: true, children: [
             "+",
             event.xp,
             " XP  "
           ] }),
-          /* @__PURE__ */ jsx8(Text8, { children: event.name }),
-          /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
+          /* @__PURE__ */ jsx7(Text7, { children: event.name }),
+          /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
             "  \u2014 ",
             description
           ] })
@@ -2609,28 +3037,81 @@ function raceViewFrom(resp) {
   };
 }
 async function buildInitialState(args) {
-  let secondary = { claude: 0, codex: 0, gemini: 0 };
-  const primaryConvAcked = {};
+  const convAcked = { anthropic: {}, openai: {}, google: {} };
   try {
-    const now = await readAllSources(args.active, args.active.primary_model);
+    const now = await readAllSources();
     if (!isStall(now)) {
-      secondary = now.secondary;
-      for (const [id, v] of now.primaryByConv) primaryConvAcked[id] = v;
+      for (const family of MODEL_FAMILIES) {
+        for (const [id, value] of now.byFamily[family]) convAcked[family][id] = value;
+      }
     }
   } catch {
   }
   return {
     initialState: {
-      acked: { ...secondary },
-      lastGood: { ...secondary },
-      primaryConvAcked,
-      primaryCounted: 0,
+      convAcked,
+      counted: zeroPerFamily(),
       seq: args.serverLastSeq
     },
     pendingMode: args.raceStatus === "pending"
   };
 }
 
+// src/tokens/source-probe.ts
+async function probeAll() {
+  const enabled = enabledHarnesses(await loadPrefs());
+  return Promise.all(enabled.map((key) => probe(HARNESSES[key])));
+}
+async function confirmNoSources(opts) {
+  if (opts.probes.some((p) => p.transcripts > 0)) return true;
+  opts.warn(opts.probes.length === 0 ? describeAllDisabled() : describeNoSources(opts.probes));
+  if (!opts.interactive) return true;
+  return opts.ask();
+}
+function describeNoSources(probes) {
+  const lines = [
+    `\u26A0 No transcripts found for any coding agent \u2014 your horse will not move.`,
+    ``
+  ];
+  for (const p of probes) {
+    const label = p.harness.label;
+    lines.push(`  ${label}: ${p.dir}`, `  ${" ".repeat(label.length)}  (${reasonFor(p)})`);
+    if (p.exists && p.projects > 0) {
+      lines.push(
+        `    Has history in it, so this is usually a dangling symlink or a`,
+        `    permissions problem. To find dangling links:`,
+        `      find ${p.dir} -type l ! -exec test -e {} \\; -print`
+      );
+    }
+    for (const hint of p.harness.hints ?? []) lines.push(`    ${hint}`);
+  }
+  lines.push(
+    ``,
+    `  Token Derby counts usage from this machine's own filesystem. If your`,
+    `  coding agent runs in a container, over SSH, or on another machine, join`,
+    `  the race from there instead.`,
+    ``,
+    `  To read them from somewhere else, set the matching directory override:`,
+    `    ${HARNESS_KEYS.map((k) => HARNESSES[k].overrideVar).join("  ")}`
+  );
+  return lines.join("\n");
+}
+function describeAllDisabled() {
+  return [
+    `\u26A0 Every coding agent is turned off \u2014 your horse will not move.`,
+    ``,
+    `  Turn one back on with:  token-derby harness enable <id>`,
+    `  See what is available:  token-derby harness list`
+  ].join("\n");
+}
+function reasonFor(probe2) {
+  if (!probe2.exists) return "does not exist";
+  if (probe2.projects > 0) {
+    return `holds ${probe2.projects} project ${probe2.projects === 1 ? "directory" : "directories"}, none of which could be read`;
+  }
+  return "exists, but holds no transcripts";
+}
+
 // src/ui/prompt.ts
 async function promptYesNo(question, opts = {}) {
   const input = opts.input ?? process.stdin;
@@ -2654,31 +3135,12 @@ function resetStdinAfterInk() {
 }
 
 // src/commands/join.ts
-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 login` to set up your identity.");
@@ -2733,7 +3195,27 @@ async function joinCommand(joinCode, argv = []) {
       console.error("Your stable is empty. Run `token-derby stable create` first.");
       return 1;
     }
-    const picked = await pickHorse(horses);
+    const choice = await resolveHorse(horses, {
+      name: parseFlag(argv, "--horse"),
+      pick: hasFlag(argv, "--pick")
+    });
+    if (choice.kind === "not_found") {
+      console.error(`No horse named "${choice.name}" in your stable.`);
+      console.error(`Your stable: ${horses.map((h) => h.name).join(", ")}`);
+      return 1;
+    }
+    if (choice.kind === "no_tty") {
+      console.error(noTtyMessage("token-derby join"));
+      return 1;
+    }
+    let picked;
+    if (choice.kind === "resolved") {
+      picked = choice.horse;
+      const notice = noticeFor(choice);
+      if (notice) console.log(notice);
+    } else {
+      picked = await pickHorse(horses);
+    }
     if (!picked) {
       console.log("Cancelled.");
       return 1;
@@ -2742,14 +3224,8 @@ async function joinCommand(joinCode, argv = []) {
     chosenName = picked.name;
     chosenColors = picked.colors;
   }
-  let chosenPrimary = "claude";
-  if (!ownHorse) {
-    if (primaryFlag) chosenPrimary = primaryFlag;
-    else if (process.stdout.isTTY) chosenPrimary = await pickPrimary();
-  }
-  const effectivePrimary = ownHorse?.primary_model ?? chosenPrimary;
-  const proceed = await confirmEmptySource({
-    probe: await probeSource(effectivePrimary),
+  const proceed = await confirmNoSources({
+    probes: await probeAll(),
     interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
     warn: (text) => console.error(`
 ${text}
@@ -2762,7 +3238,7 @@ ${text}
   }
   let joinResp;
   try {
-    joinResp = await joinRace(code, { stable_horse_id: chosenStableHorseId, primary_model: chosenPrimary });
+    joinResp = await joinRace(code, { stable_horse_id: chosenStableHorseId });
   } catch (e) {
     if (e instanceof ApiError) {
       if (e.code === "RACE_FULL") console.error("This race is full.");
@@ -2788,27 +3264,22 @@ ${text}
     horse_colors: chosenColors,
     joined_at: ownHorse?.joined_at ?? (/* @__PURE__ */ new Date()).toISOString(),
     last_heartbeat_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-    primary_model: joinResp.primary_model,
     score: {
-      acked: { claude: 0, codex: 0, gemini: 0 },
-      lastGood: { claude: 0, codex: 0, gemini: 0 },
-      primaryConvAcked: {},
-      primaryCounted: 0,
+      convAcked: { anthropic: {}, openai: {}, google: {} },
+      counted: { anthropic: 0, openai: 0, google: 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(React9.createElement(RunRace, { active, initialState: initial.initialState, pendingMode: initial.pendingMode, ownUserName: identity.display_name }));
+  const app = render4(React5.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(
-      React9.createElement(HorsePicker, {
+      React5.createElement(HorsePicker, {
         horses,
         onPick: (h) => {
           app.unmount();
@@ -2822,18 +3293,6 @@ 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";
@@ -3558,16 +4017,16 @@ function runNpmUpgrade(spawnImpl) {
 }
 
 // src/commands/roll.ts
-import React14 from "react";
+import React7 from "react";
 import { render as render6 } from "ink";
 
 // src/ui/RollHorsePicker.tsx
-import { useState as useState6 } from "react";
-import { Box as Box9, Text as Text9, useInput as useInput4 } from "ink";
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+import { useState as useState5 } from "react";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 function RollHorsePicker({ horses, onPick, onCancel }) {
-  const [idx, setIdx] = useState6(0);
-  useInput4((input, key) => {
+  const [idx, setIdx] = useState5(0);
+  useInput3((input, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -3586,61 +4045,61 @@ function RollHorsePicker({ horses, onPick, onCancel }) {
       return;
     }
   });
-  return /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx9(Text9, { children: "Pick a horse to roll for:" }),
-    horses.map((h, i) => /* @__PURE__ */ jsxs7(Box9, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(Box9, { flexDirection: "row", children: /* @__PURE__ */ jsxs7(Text9, { children: [
+  return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Text8, { children: "Pick a horse to roll for:" }),
+    horses.map((h, i) => /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx8(Box8, { flexDirection: "row", children: /* @__PURE__ */ jsxs6(Text8, { children: [
         i === idx ? "\u25BA" : " ",
         " ",
         h.name,
         " ",
-        /* @__PURE__ */ jsxs7(Text9, { color: "cyan", children: [
+        /* @__PURE__ */ jsxs6(Text8, { color: "cyan", children: [
           "[Lvl. ",
           levelFromXp(h.xp),
           "]"
         ] }),
         " ",
-        /* @__PURE__ */ jsxs7(Text9, { color: "yellow", children: [
+        /* @__PURE__ */ jsxs6(Text8, { color: "yellow", children: [
           "\u2014 ",
           h.pending,
           " roll",
           h.pending === 1 ? "" : "s"
         ] })
       ] }) }),
-      /* @__PURE__ */ jsxs7(Box9, { flexDirection: "row", children: [
-        /* @__PURE__ */ jsx9(Text9, { children: "  " }),
-        /* @__PURE__ */ jsx9(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors })
+      /* @__PURE__ */ jsxs6(Box8, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsx8(Text8, { children: "  " }),
+        /* @__PURE__ */ jsx8(HorseSprite, { sprite: MINI_SPRITE, colors: h.colors })
       ] })
     ] }, h.stable_horse_id)),
-    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "\u2191/\u2193 choose \xB7 Enter pick \xB7 Esc cancel" }) })
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2191/\u2193 choose \xB7 Enter pick \xB7 Esc cancel" }) })
   ] });
 }
 
 // src/ui/reveal.ts
-import React13 from "react";
+import React6 from "react";
 import { render as render5 } from "ink";
 
 // src/ui/RollReveal.tsx
-import { useState as useState8, useEffect as useEffect4, useMemo } from "react";
-import { Box as Box11, Text as Text11 } 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 useState7 } from "react";
-import { Box as Box10, Text as Text10 } from "ink";
-import { jsx as jsx10 } 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 = hatColors(hat, variant ?? 0);
   const grid = makeHatGrid(hat, colors, centerIn);
   const lines = hexGridToHalfBlocks(grid);
-  return /* @__PURE__ */ jsx10(Box10, { flexDirection: "column", children: lines.map((line, i) => /* @__PURE__ */ jsx10(Text10, { 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 (!isAnimatedHat(hat)) {
-    return /* @__PURE__ */ jsx10(HatSprite, { hat, variant, centerIn });
+    return /* @__PURE__ */ jsx9(HatSprite, { hat, variant, centerIn });
   }
   const frames = hat.animation.frames;
   const fps = hat.animation.fps;
-  const [idx, setIdx] = useState7(0);
+  const [idx, setIdx] = useState6(0);
   useEffect3(() => {
     if (frames.length <= 1) return;
     const interval = setInterval(
@@ -3650,7 +4109,7 @@ function AnimatedHatSprite({ hat, variant, centerIn }) {
     return () => clearInterval(interval);
   }, [frames.length, fps]);
   const framed = { ...hat, colors: { ...hat.colors, A: frames[idx] } };
-  return /* @__PURE__ */ jsx10(HatSprite, { hat: framed, variant, centerIn });
+  return /* @__PURE__ */ jsx9(HatSprite, { hat: framed, variant, centerIn });
 }
 function makeHatGrid(hat, colors, centerIn) {
   const w = centerIn?.w ?? hat.width;
@@ -3673,7 +4132,7 @@ function makeHatGrid(hat, colors, centerIn) {
 }
 
 // src/ui/RollReveal.tsx
-import { jsx as jsx11 } from "react/jsx-runtime";
+import { jsx as jsx10 } from "react/jsx-runtime";
 var RESET3 = "\x1B[0m";
 var BOX_COLOR = "#E5C76B";
 var TIER_PALETTE = {
@@ -3743,13 +4202,13 @@ var BOX_EMPTY = [
   ""
 ].map(pad);
 function GiftBox({ frame, color }) {
-  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: frame.map((line, i) => /* @__PURE__ */ jsx11(Text11, { 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) {
+function spawnParticles(tier, count2, cx, cy) {
   const palette = TIER_PALETTE[tier];
   const out = [];
-  for (let i = 0; i < count; i++) {
-    const angle = i / count * Math.PI * 2 + (Math.random() - 0.5) * 0.6;
+  for (let i = 0; i < count2; i++) {
+    const angle = i / count2 * Math.PI * 2 + (Math.random() - 0.5) * 0.6;
     const speed = 0.8 + Math.random() * 1.6;
     out.push({
       x: cx,
@@ -3766,7 +4225,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] = useState8(0);
+  const [tick, setTick] = useState7(0);
   useEffect4(() => {
     const i = setInterval(() => setTick((t) => t + 1), 70);
     return () => clearInterval(i);
@@ -3779,13 +4238,13 @@ function ConfettiBurst({ tier }) {
       grid[y][x] = ansiFg(p.color) + p.char + RESET3;
     }
   }
-  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: grid.map((row, y) => /* @__PURE__ */ jsx11(Text11, { 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 isShowpiece = outcome.kind !== "no_hat" && (outcome.hat.rarity === "legendary" || outcome.hat.rarity === "limited");
-  const [phase, setPhase] = useState8("closed");
+  const [phase, setPhase] = useState7("closed");
   useEffect4(() => {
     const timers = [];
     timers.push(setTimeout(() => setPhase("open1"), CLOSED_HOLD_MS));
@@ -3800,21 +4259,21 @@ function RollReveal({ outcome, onDone }) {
     }
     return () => timers.forEach(clearTimeout);
   }, [isNoHat, isShowpiece, onDone]);
-  if (phase === "closed") return /* @__PURE__ */ jsx11(GiftBox, { frame: BOX_CLOSED, color: BOX_COLOR });
-  if (phase === "open1") return /* @__PURE__ */ jsx11(GiftBox, { frame: BOX_OPENING_1, color: BOX_COLOR });
-  if (phase === "open2") return /* @__PURE__ */ jsx11(GiftBox, { frame: BOX_OPENING_2, color: BOX_COLOR });
-  if (phase === "empty") return /* @__PURE__ */ jsx11(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__ */ jsx11(ConfettiBurst, { tier: outcome.hat.rarity });
+    return /* @__PURE__ */ jsx10(ConfettiBurst, { tier: outcome.hat.rarity });
   }
-  if (outcome.kind === "no_hat") return /* @__PURE__ */ jsx11(GiftBox, { frame: BOX_EMPTY, color: BOX_COLOR });
-  return isAnimatedHat(outcome.hat) ? /* @__PURE__ */ jsx11(AnimatedHatSprite, { hat: outcome.hat, centerIn: { w: SCENE_W, h: SCENE_H } }) : /* @__PURE__ */ jsx11(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 isAnimatedHat(outcome.hat) ? /* @__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/reveal.ts
 async function runReveal(outcome) {
   await new Promise((resolve) => {
-    const app = render5(React13.createElement(RollReveal, {
+    const app = render5(React6.createElement(RollReveal, {
       outcome,
       onDone: () => {
         app.unmount();
@@ -3830,7 +4289,7 @@ function pendingFor(horse) {
   const lastRolled = horse.last_rolled_level ?? Math.max(1, level - 1);
   return level - lastRolled;
 }
-async function rollCommand() {
+async function rollCommand(args = []) {
   let stable;
   try {
     stable = await listStable();
@@ -3846,19 +4305,39 @@ async function rollCommand() {
     console.log("No rolls available. Level up a horse to earn a roll!");
     return 0;
   }
-  const picked = await new Promise((resolve) => {
-    const app = render6(React14.createElement(RollHorsePicker, {
-      horses: eligible,
-      onPick: (h) => {
-        app.unmount();
-        resolve(h);
-      },
-      onCancel: () => {
-        app.unmount();
-        resolve(null);
-      }
-    }));
+  const choice = await resolveHorse(eligible, {
+    name: parseFlag(args, "--horse"),
+    autoSelect: false
   });
+  if (choice.kind === "not_found") {
+    console.error(`No horse named "${choice.name}" has a roll available.`);
+    console.error(`With rolls: ${eligible.map((h) => h.name).join(", ")}`);
+    return 1;
+  }
+  if (choice.kind === "no_tty") {
+    console.error(noTtyMessage("token-derby roll"));
+    return 1;
+  }
+  let picked;
+  if (choice.kind === "resolved") {
+    picked = choice.horse;
+    const notice = noticeFor(choice);
+    if (notice) console.log(notice);
+  } else {
+    picked = await new Promise((resolve) => {
+      const app = render6(React7.createElement(RollHorsePicker, {
+        horses: eligible,
+        onPick: (h) => {
+          app.unmount();
+          resolve(h);
+        },
+        onCancel: () => {
+          app.unmount();
+          resolve(null);
+        }
+      }));
+    });
+  }
   if (!picked) {
     console.log("Cancelled.");
     return 0;
@@ -3903,7 +4382,9 @@ async function rollCommand() {
       console.log(`
 \u2728 ${hat.name}${variantSuffix} [${hat.rarity.toUpperCase()}]
 `);
-      if (await promptYesNo("Equip now? [Y/n] ")) {
+      if (!interactive()) {
+        console.log(`Not equipped \u2014 no terminal to confirm. Equip it with: token-derby stable edit "${chosen.name}"`);
+      } else if (await promptYesNo("Equip now? [Y/n] ")) {
         try {
           await equipHat(chosen.stable_horse_id, { hat_index: result.hat_index });
           console.log(`Equipped on ${chosen.name}.`);
@@ -3925,21 +4406,25 @@ No hat this time. +${result.xp_awarded} XP toward your next level.
 `);
     }
     if (result.remaining_rolls <= 0) return 0;
+    if (!interactive()) {
+      console.log(`${result.remaining_rolls} more roll${result.remaining_rolls === 1 ? "" : "s"} available. Run again to spend another.`);
+      return 0;
+    }
     if (!await promptYesNo(`${result.remaining_rolls} more roll${result.remaining_rolls === 1 ? "" : "s"} available. Roll again? [Y/n] `)) return 0;
   }
 }
 
 // src/commands/claim.ts
-import React15 from "react";
+import React8 from "react";
 import { render as render7 } from "ink";
-async function claimCommand(token) {
+async function claimCommand(token, args = []) {
   if (!token) {
     console.error("Usage: token-derby claim <token>");
     return 2;
   }
-  let probe;
+  let probe2;
   try {
-    probe = await probeClaim(token);
+    probe2 = await probeClaim(token);
   } catch (e) {
     if (e instanceof ApiError) {
       console.error(`Error: ${e.code} ${e.message}`);
@@ -3961,23 +4446,44 @@ async function claimCommand(token) {
     console.error("No horses in your stable. Run `token-derby stable create` first.");
     return 1;
   }
-  console.log(probe.entry_count > 1 ? `
-\u{1F381} A pack of ${probe.entry_count} cosmetics \u2014 one of them will be yours.
-` : "\n\u{1F381} A cosmetic has been awarded to you.\n");
-  const picked = await new Promise((resolve) => {
-    const app = render7(React15.createElement(HorsePicker, {
-      horses: stable.horses,
-      prompt: "Which horse should receive it?",
-      onPick: (h) => {
-        app.unmount();
-        resolve(h);
-      },
-      onCancel: () => {
-        app.unmount();
-        resolve(null);
-      }
-    }));
+  const choice = await resolveHorse(stable.horses, {
+    name: parseFlag(args, "--horse"),
+    pick: hasFlag(args, "--pick")
   });
+  if (choice.kind === "not_found") {
+    console.error(`No horse named "${choice.name}" in your stable.`);
+    console.error(`Your stable: ${stable.horses.map((h) => h.name).join(", ")}`);
+    return 1;
+  }
+  if (choice.kind === "no_tty") {
+    console.error(noTtyMessage("token-derby claim"));
+    console.error("Your token is unspent.");
+    return 1;
+  }
+  console.log(probe2.entry_count > 1 ? `
+\u{1F381} A pack of ${probe2.entry_count} cosmetics \u2014 one of them will be yours.
+` : "\n\u{1F381} A cosmetic has been awarded to you.\n");
+  let picked;
+  if (choice.kind === "resolved") {
+    picked = choice.horse;
+    const notice = noticeFor(choice);
+    if (notice) console.log(notice + "\n");
+  } else {
+    picked = await new Promise((resolve) => {
+      const app = render7(React8.createElement(HorsePicker, {
+        horses: stable.horses,
+        prompt: "Which horse should receive it?",
+        onPick: (h) => {
+          app.unmount();
+          resolve(h);
+        },
+        onCancel: () => {
+          app.unmount();
+          resolve(null);
+        }
+      }));
+    });
+  }
   if (!picked) {
     console.log("Cancelled. Your token is unspent.");
     return 0;
@@ -4011,7 +4517,9 @@ async function claimCommand(token) {
     console.log(`
 \u2728 ${hat2.name}${variantSuffix2} [${hat2.rarity.toUpperCase()}]
 `);
-    if (await promptYesNo("Equip now? [Y/n] ")) {
+    if (!interactive()) {
+      console.log(`Not equipped \u2014 no terminal to confirm. Equip it with: token-derby stable edit "${picked.name}"`);
+    } else if (await promptYesNo("Equip now? [Y/n] ")) {
       try {
         await equipHat(picked.stable_horse_id, { hat_index: result.hat_index });
         console.log(`Equipped on ${picked.name}.`);
@@ -4031,6 +4539,121 @@ ${picked.name} already has ${hat?.name ?? result.hat_id}${variantSuffix}. +${res
   return 0;
 }
 
+// src/commands/stable-default.ts
+async function stableDefaultCommand(args) {
+  const clear = args.includes("--clear");
+  const name = args.find((a) => !a.startsWith("--"));
+  if (clear && name !== void 0) {
+    console.error("Pass a name or --clear, not both.");
+    return 2;
+  }
+  if (clear) {
+    await clearDefaultHorse();
+    console.log("Default horse cleared.");
+    return 0;
+  }
+  let horses;
+  try {
+    horses = (await listStable()).horses;
+  } catch (e) {
+    if (e instanceof ApiError) {
+      console.error(`Error: ${e.code} ${e.message}`);
+      return 1;
+    }
+    throw e;
+  }
+  if (name === void 0) return showCurrent(horses);
+  const found = horses.find((h) => h.name === name);
+  if (!found) {
+    console.error(`No horse named "${name}" in your stable.`);
+    if (horses.length > 0) console.error(`Your stable: ${horses.map((h) => h.name).join(", ")}`);
+    return 1;
+  }
+  await setDefaultHorse(found.stable_horse_id);
+  console.log(`Default horse set: ${describeHorse(found)}`);
+  return 0;
+}
+async function showCurrent(horses) {
+  const { default_stable_horse_id } = await loadPrefs();
+  if (default_stable_horse_id === void 0) {
+    console.log("No default horse set.");
+    console.log("Set one with: token-derby stable default <name>");
+    return 0;
+  }
+  const found = horses.find((h) => h.stable_horse_id === default_stable_horse_id);
+  if (!found) {
+    console.log("Your default horse is no longer in your stable \u2014 it will be ignored.");
+    console.log("Set a new one with: token-derby stable default <name>");
+    return 0;
+  }
+  console.log(`Default horse: ${describeHorse(found)}`);
+  return 0;
+}
+
+// src/commands/harness.ts
+function isHarnessKey(v) {
+  return HARNESS_KEYS.includes(v);
+}
+function listValidIds() {
+  return HARNESS_KEYS.join(", ");
+}
+async function harnessListCommand() {
+  const prefs = await loadPrefs();
+  const rows = await Promise.all(HARNESS_KEYS.map(async (key) => {
+    const p = await probe(HARNESSES[key]);
+    return {
+      key,
+      label: HARNESSES[key].label,
+      on: isHarnessEnabled(prefs, key),
+      chosen: prefs.harnesses?.[key] !== void 0,
+      byDefault: HARNESSES[key].enabledByDefault,
+      found: p.transcripts,
+      dir: p.dir
+    };
+  }));
+  const width = Math.max(...rows.map((r) => r.key.length));
+  console.log("");
+  for (const r of rows) {
+    const state = r.on ? "on " : "off";
+    const why = r.chosen ? "" : r.byDefault ? "  (default)" : "  (off by default \u2014 enable to count it)";
+    const found = r.found === 1 ? "1 transcript" : `${r.found} transcripts`;
+    console.log(`  ${state}  ${r.key.padEnd(width)}  ${r.label}${why}`);
+    console.log(`       ${" ".repeat(width)}  ${r.dir}  (${found})`);
+  }
+  console.log("");
+  console.log("  token-derby harness disable <id>   stop counting one");
+  console.log("  token-derby harness enable <id>    start counting it again");
+  console.log("");
+  return 0;
+}
+async function harnessToggleCommand(id, enabled) {
+  const verb = enabled ? "enable" : "disable";
+  if (!id) {
+    console.error(`Usage: token-derby harness ${verb} <id>`);
+    console.error(`Available: ${listValidIds()}`);
+    return 2;
+  }
+  if (!isHarnessKey(id)) {
+    console.error(`Unknown coding agent '${id}'.`);
+    console.error(`Available: ${listValidIds()}`);
+    return 2;
+  }
+  const before = await loadPrefs();
+  if (isHarnessEnabled(before, id) === enabled) {
+    console.log(`${HARNESSES[id].label} is already ${enabled ? "counted" : "turned off"}.`);
+    return 0;
+  }
+  await setHarnessEnabled(id, enabled);
+  const remaining = enabledHarnesses(await loadPrefs());
+  console.log(`${HARNESSES[id].label} is now ${enabled ? "counted" : "turned off"}.`);
+  console.log("Takes effect on your next heartbeat \u2014 no need to rejoin.");
+  if (remaining.length === 0) {
+    console.log("");
+    console.log("\u26A0 Every coding agent is now off, so your horse will not move.");
+  }
+  return 0;
+}
+
 // src/commands/org-join.ts
 async function orgJoinCommand(token) {
   const join_token = token?.trim();
@@ -4077,6 +4700,31 @@ function envCommand(arg) {
   return 0;
 }
 
+// src/commands/logs.ts
+import * as fs11 from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+var DEFAULT_TAIL_LINES = 50;
+function tailCount(argv) {
+  const i = argv.indexOf("--tail");
+  if (i === -1) return null;
+  const n = Number(argv[i + 1]);
+  return Number.isInteger(n) && n > 0 ? n : DEFAULT_TAIL_LINES;
+}
+async function logsCommand(argv) {
+  const file = logFile();
+  if (!existsSync2(file)) {
+    console.log(`No log file yet \u2014 it appears at ${file} the first time a command runs.`);
+    return 0;
+  }
+  console.log(file);
+  const n = tailCount(argv);
+  if (n === null) return 0;
+  const lines = (await fs11.readFile(file, "utf8")).split("\n").filter((l) => l.length > 0);
+  console.log("");
+  for (const line of lines.slice(-n)) console.log(line);
+  return 0;
+}
+
 // src/bin.ts
 var HELP = `token-derby v${CLI_VERSION}
 
@@ -4105,12 +4753,23 @@ Identity:
 
 Maintenance:
   token-derby update                      Check for and install the latest CLI version
+  token-derby logs                        Show the path of the debug log
+  token-derby logs --tail [n]             Print the last n log lines (default 50)
+
+Coding agents:
+  token-derby harness list                Show which agents this machine counts,
+                                          and whether they have anything to count
+  token-derby harness disable <id>        Stop counting one (takes effect next heartbeat)
+  token-derby harness enable <id>         Start counting it again
 
 Stable management:
   token-derby stable create               Make a new horse (interactive)
   token-derby stable list                 Show your saved horses
   token-derby stable edit [name]          Edit an existing horse's colors (interactive picker if no name)
   token-derby stable delete <name>        Remove a horse from your stable
+  token-derby stable default [name]       Show, set, or (--clear) unset the horse that
+                                          claim/join/stable edit use when none is named.
+                                          A stable of one is used automatically.
 
 Organisations:
   token-derby organisation join [token]   Join an organisation with a join token,
@@ -4124,13 +4783,17 @@ Races:
                                           Create a new race (interactive). When
                                           --organisation is set, only members of
                                           that org can join.
-  token-derby join <join-code>            Join (or resume) a race
+  token-derby join <join-code> [--horse <name>|--pick]
+                                          Join (or resume) a race
   token-derby end <admin-code>            End a race early
 
 Cosmetics:
-  token-derby roll                        Spend a pending roll to try for a hat.
-                                          Earn rolls by leveling up horses.
-  token-derby claim <token>               Redeem a claim token for a cosmetic
+  token-derby roll [--horse <name>]       Spend a pending roll to try for a hat.
+                                          Earn rolls by leveling up horses. The picker
+                                          is a confirmation step, so it is shown unless
+                                          --horse names the horse outright.
+  token-derby claim <token> [--horse <name>|--pick]
+                                          Redeem a claim token for a cosmetic
                                           awarded to you by an admin.
 
 Environment:
@@ -4141,9 +4804,25 @@ Environment:
   TOKEN_DERBY_API_BASE                    Hard-override API base URL (wins over env)
   TOKEN_DERBY_HOME                        Hard-override identity/stable directory
 `;
+function describeInvocation(argv) {
+  const cmd = argv[0] ?? "(none)";
+  const container = cmd === "stable" || cmd === "organisation" || cmd === "org" || cmd === "harness";
+  return {
+    cmd,
+    sub: container ? argv[1] : void 0,
+    flags: argv.filter((a) => a.startsWith("--")).map((a) => a.split("=")[0])
+  };
+}
 async function main() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
+  logInfo("cmd.start", {
+    ...describeInvocation(argv),
+    version: CLI_VERSION,
+    node: process.version,
+    pid: process.pid,
+    env: selectedEnv()
+  });
   if (!cmd || cmd === "--help" || cmd === "-h") {
     console.log(HELP);
     return 0;
@@ -4159,6 +4838,16 @@ async function main() {
   if (cmd === "login") return loginCommand(argv.slice(1));
   if (cmd === "update") return updateCommand();
   if (cmd === "env") return envCommand(argv[1]);
+  if (cmd === "logs") return logsCommand(argv.slice(1));
+  if (cmd === "harness") {
+    const sub = argv[1];
+    if (sub === void 0 || sub === "list") return harnessListCommand();
+    if (sub === "enable") return harnessToggleCommand(argv[2], true);
+    if (sub === "disable") return harnessToggleCommand(argv[2], false);
+    console.error(`Unknown harness subcommand: ${sub}`);
+    console.error("Try: harness list | harness enable <id> | harness disable <id>");
+    return 2;
+  }
   const identity = await loadIdentity();
   if (!identity) {
     console.error("Run `token-derby login` to set up your identity before using any other command.");
@@ -4170,8 +4859,9 @@ async function main() {
     if (sub === "list") return stableListCommand();
     if (sub === "edit") return stableEditCommand(argv[2]);
     if (sub === "delete") return stableDeleteCommand(argv[2]);
+    if (sub === "default") return stableDefaultCommand(argv.slice(2));
     console.error(`Unknown stable subcommand: ${sub ?? "(none)"}`);
-    console.error("Try: stable create | stable list | stable edit <name> | stable delete <name>");
+    console.error("Try: stable create | stable list | stable edit <name> | stable delete <name> | stable default [<name>|--clear]");
     return 2;
   }
   if (cmd === "organisation" || cmd === "org") {
@@ -4190,24 +4880,40 @@ async function main() {
   if (cmd === "whoami") return whoamiCommand();
   if (cmd === "join") return joinCommand(argv[1], argv.slice(2));
   if (cmd === "end") return endCommand(argv[1]);
-  if (cmd === "roll") return rollCommand();
-  if (cmd === "claim") return claimCommand(argv[1]);
+  if (cmd === "roll") return rollCommand(argv.slice(1));
+  if (cmd === "claim") return claimCommand(argv[1], argv.slice(2));
   if (cmd === "web") return webCommand();
   console.error(`Unknown command: ${cmd}`);
   console.error(HELP);
   return 2;
 }
-function parseFlag(args, flag) {
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === flag) return args[i + 1];
-    const eq = `${flag}=`;
-    if (args[i]?.startsWith(eq)) return args[i].slice(eq.length);
-  }
-  return void 0;
+var CRASH_HANDLERS_INSTALLED = /* @__PURE__ */ Symbol.for("token-derby.crash-handlers");
+if (!(CRASH_HANDLERS_INSTALLED in process)) {
+  process[CRASH_HANDLERS_INSTALLED] = true;
+  process.on("uncaughtException", (err) => {
+    logError("cmd.uncaught", { message: err?.message ?? String(err), stack: err?.stack });
+    console.error(err?.stack ?? err);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logError("cmd.unhandled", {
+      message: reason?.message ?? String(reason),
+      stack: reason?.stack
+    });
+  });
 }
+var startedAt = Date.now();
 main().then(
-  (code) => process.exit(code),
+  (code) => {
+    logInfo("cmd.exit", { code, ms: Date.now() - startedAt });
+    process.exit(code);
+  },
   (err) => {
+    logError("cmd.crash", {
+      message: err?.message ?? String(err),
+      stack: err?.stack,
+      ms: Date.now() - startedAt
+    });
     console.error(err?.stack ?? err);
     process.exit(1);
   }