token-larper 1.9.0 → 1.10.1

package/README.md

@@ -21,11 +21,11 @@ Token Larper passively reads session files, SQLite databases, and telemetry logs
 It consolidates all sessions into a real-time, interactive local dashboard running on [`http://localhost:4269`](http://localhost:4269) on **Windows, macOS, and Linux**. On Windows, it also lives quietly in your notification area as a lightweight, DPI-aware system tray icon.
 
 * **Powered by `ccusage`**: Uses `ccusage` v20+ for cross-platform log parsing, token counting, and verified frontier model pricing.
-* **100% Private & Offline**: No API keys required, no external proxies to configure, and zero analytics or telemetry sent to the cloud. The one outbound request is an optional update check that asks npm for the latest version number; turn it off in **Settings → Updates**.
+* **100% Private & Offline**: No API keys required, no external proxies to configure, and zero analytics or telemetry sent to the cloud. The only outbound requests are two optional ones that send nothing about your usage: an update check that asks npm for the latest version number (turn it off in **Settings → Updates**), and a once-a-day download of OpenRouter's public model price list for cost estimates (set `TOKEN_LARPER_OFFLINE=1` to skip it).
 * **Cross-Platform Core**: The telemetry engine, 18 harness scrapers, and React dashboard run identically across Windows, macOS (Apple Silicon & Intel), and Linux.
 * **Gamified Hall of Larp**: Track your lifetime token burn, unlock 14 achievements, climb an 11-tier ranking ladder past rival personas, and export a shareable 1200×630 flex badge.
 * **Six Styles, Your Colors**: Grove, Terminal, Paper, Brutal, Soft, and Mono each change fonts, corner radius, spacing, borders, and shadows, not just colors. Pick a base color that tints backgrounds, borders, and text, and an accent for highlights, from presets or any custom color. Or import a tweakcn/shadcn CSS theme on top.
-* **Subscription-Aware**: Distinguishes between strict verified API billing and estimated **"LARP Value"** (the theoretical API cost of tokens consumed through flat-rate subscriptions like Claude Pro/Max, Copilot, or Antigravity).
+* **Subscription-Aware**: Distinguishes between strict verified API billing and estimated **"LARP Value"** (the theoretical API cost of tokens consumed through flat-rate subscriptions like Claude Pro/Max, Copilot, or Antigravity). Estimates use [OpenRouter's](https://openrouter.ai/models) current list prices, so new models are priced without waiting for an update.
 
 ---
 
@@ -247,6 +247,11 @@ Set `TOKEN_LARPER_DATA_DIR` to use another folder. Versions before 1.5.0 kept th
 ### Updates
 When a new version is on npm, the dashboard shows a banner. **Update now** starts `bunx token-larper@latest` in the background; the new version replaces the running one on the same port and the dashboard reloads. You can also check from **Settings → Updates**, or turn automatic checks off there. A copy cloned from git updates with `git pull`.
 
+### Estimated Prices
+When ccusage has no price for a model (a brand-new one, or usage through a flat-rate subscription), Token Larper estimates the cost from list prices. It downloads OpenRouter's public model price list once a day, keeps it in the data folder as `openrouter-pricing.json`, and prices any model on that list from it. Other models use rates built into the app. Only the price list is downloaded; nothing about your usage is sent, and if the download fails the last saved list is used.
+
+Estimates do not include OpenRouter's long-context surcharges, and a model name that OpenRouter spells differently may fall back to the built-in rates. Verified costs from ccusage are never changed. Set `TOKEN_LARPER_OFFLINE=1` to skip the download and use only the saved list (if any) and the built-in rates.
+
 ### Headless Server Mode
 If running on a remote headless server or Docker container, you can explicitly disable the tray icon (automatically disabled on macOS/Linux):
 ```bash

package/bin/cli.js

@@ -32,7 +32,7 @@ function dataDir() {
 
 function bunPath() {
   if (typeof Bun !== "undefined") return process.execPath;
-  if (spawnSync("bun", ["--version"], { stdio: "ignore" }).status === 0) return "bun";
+  if (spawnSync("bun", ["--version"], { stdio: "ignore", windowsHide: true }).status === 0) return "bun";
   console.error("🔥 Token Larper requires Bun (v1.1+) to run.");
   console.error("\nInstall Bun with one command:");
   if (process.platform === "win32") {
@@ -85,26 +85,47 @@ async function foreground() {
   process.exit(child.status ?? 0);
 }
 
+/**
+ * Start the server so it outlives this terminal. On Windows it goes through Start-Process:
+ * the server then gets a hidden console that everything it starts shares (a process with
+ * no console at all makes Windows open a window for each console program it runs), and it
+ * inherits no handles, so it can't end up holding an older copy's port when this CLI was
+ * itself started by one during an update. The server writes its own log (src/logFile.ts).
+ */
+function startServerProcess(bun, env) {
+  if (process.platform === "win32") {
+    const quote = (value) => `'${value.replace(/'/g, "''")}'`;
+    const command = [
+      "Start-Process -WindowStyle Hidden",
+      `-FilePath ${quote(bun)}`,
+      `-ArgumentList ${quote(`"${serverScript}"`)}`,
+      `-WorkingDirectory ${quote(rootDir)}`,
+    ].join(" ");
+    const hop = spawnSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+      stdio: "ignore",
+      windowsHide: true,
+      env,
+    });
+    return hop.status === 0;
+  }
+  spawn(bun, [serverScript], { cwd: rootDir, detached: true, stdio: "ignore", env }).unref();
+  return true;
+}
+
 async function background(open) {
   const bun = bunPath();
   const dir = dataDir();
   mkdirSync(dir, { recursive: true });
   const logFile = join(dir, "server.log");
-  const log = openSync(logFile, "w");
+  closeSync(openSync(logFile, "w"));
 
   // The server moves to the next free port if another program has this one, and takes
   // over from an older Token Larper on the same port (see src/server.ts).
-  const child = spawn(bun, [serverScript], {
-    cwd: rootDir,
-    detached: true,
-    windowsHide: true,
-    stdio: ["ignore", log, log],
-    env: { ...process.env, TOKEN_LARPER_NO_BROWSER: "1" },
+  const started = startServerProcess(bun, {
+    ...process.env,
+    TOKEN_LARPER_NO_BROWSER: "1",
+    TOKEN_LARPER_LOG_FILE: logFile,
   });
-  let exited = false;
-  child.on("exit", () => (exited = true));
-  child.unref();
-  closeSync(log);
 
   const readLog = () => {
     try {
@@ -117,10 +138,22 @@ async function background(open) {
   // Ready once the server says where it is listening. A copy of the same version that
   // is already running says so too ("already running at ..."), then the new one exits.
   let url = null;
-  for (let i = 0; i < 120 && !url; i++) {
+  let waitingForPort = false;
+  for (let i = 0; started && i < 120 && !url; i++) {
     await sleep(250);
-    url = readLog().match(/running at (http:\/\/localhost:\d+)/)?.[1] ?? null;
-    if (!url && exited) break;
+    const text = readLog();
+    url = text.match(/running at (http:\/\/localhost:\d+)/)?.[1] ?? null;
+    // Taking over from an older copy can take a minute while its port is released. This
+    // CLI may be holding that port itself (when the old copy started it for an update),
+    // so leave now instead of waiting.
+    waitingForPort = !url && text.includes("Waiting for port");
+    if (waitingForPort) break;
+    if (/Token Larper stopped:/.test(text)) break;
+  }
+
+  if (waitingForPort) {
+    console.log(`🔥 Token Larper is replacing an older copy. It will be at http://localhost:${port} in a minute.`);
+    process.exit(0);
   }
 
   if (!url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-larper",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "Token Larper — Multi-Harness AI Coding Usage & Cost Telemetry Dashboard powered by ccusage",
   "type": "module",
   "license": "MIT",

package/src/ccusage.ts

@@ -14,6 +14,7 @@ import type {
 import { isoWeek, localDateKey } from "./client/utils.ts";
 import { opencodeSessionUpdated, resolveSessionProject, saveSessionProjects } from "./projects.ts";
 import { APP_ROOT, DATA_DIR } from "./paths.ts";
+import { pricing, type Rates } from "./pricing.ts";
 
 const ROOT_DIR = APP_ROOT;
 const CACHE_DIR = DATA_DIR;
@@ -260,12 +261,6 @@ function resolveCcusageBinary(): { cmd: string[]; version: string } {
   return { cmd: ["bunx", "ccusage"], version };
 }
 
-/**
- * Estimates realistic frontier API cost in USD when ccusage reports missingPricing: true or 0 cost
- * (e.g. for bleeding-edge models like claude-opus-5-5, gpt-6-sol, minimax-m3-free, etc.).
- */
-type Rates = [input: number, output: number, cacheWrite: number, cacheRead: number];
-
 /**
  * Anthropic list prices per 1M tokens, by family and version. Opus dropped from $15/$75
  * at 4.5, so a single "opus" rate overstated newer models about threefold. Names come in
@@ -295,6 +290,11 @@ export function claudeRates(model: string): Rates | null {
   return [0.25, 1.25, 0.3, 0.03];
 }
 
+/**
+ * Estimates realistic frontier API cost in USD when ccusage reports missingPricing: true or 0 cost
+ * (e.g. for bleeding-edge models like claude-opus-5-5, gpt-6-sol, minimax-m3-free, etc.).
+ * Rates come from OpenRouter's price list when it lists the model, otherwise the built-in ones below.
+ */
 export function estimateFrontierCost(params: {
   modelName: string;
   inputTokens: number;
@@ -309,9 +309,9 @@ export function estimateFrontierCost(params: {
   // Pricing in USD per 1M tokens: [input, output, cacheWrite, cacheRead]
   let rates: Rates = [2.0, 8.0, 2.5, 0.2];
 
-  const claude = claudeRates(m);
-  if (claude) {
-    rates = claude;
+  const known = pricing.lookup(m) ?? claudeRates(m);
+  if (known) {
+    rates = known;
   } else if (m.includes("gpt-6") || m.includes("gpt-5") || m.includes("o3") || m.includes("o4")) {
     rates = [2.5, 10.0, 2.5, 0.25];
   } else if (m.includes("gemini") && m.includes("pro")) {
@@ -337,6 +337,21 @@ export function estimateFrontierCost(params: {
   );
 }
 
+// Runs still in progress. On Windows a child keeps the server's listening socket open, so
+// shutdown stops them; otherwise a newer copy can't take over the port.
+const activeRuns = new Set<ReturnType<typeof Bun.spawn>>();
+
+export function stopCcusageRuns(): void {
+  for (const proc of activeRuns) {
+    try {
+      proc.kill();
+    } catch {
+      // Already exited.
+    }
+  }
+  activeRuns.clear();
+}
+
 async function runCcusageJson(subcommandArgs: string[], timeoutMs = 25000): Promise<any | null> {
   const { cmd } = resolveCcusageBinary();
   let timer: ReturnType<typeof setTimeout> | undefined;
@@ -345,7 +360,10 @@ async function runCcusageJson(subcommandArgs: string[], timeoutMs = 25000): Prom
     const proc = Bun.spawn([...cmd, ...subcommandArgs, "--json", "-O"], {
       stdout: "pipe",
       stderr: "ignore",
+      windowsHide: true,
     });
+    activeRuns.add(proc);
+    void proc.exited.finally(() => activeRuns.delete(proc));
 
     timer = setTimeout(() => {
       try {
@@ -583,6 +601,10 @@ async function syncAntigravityInBackground(): Promise<void> {
 async function runHarnessRefresh(options?: { forceDeepScan?: boolean }): Promise<DashboardPayload> {
   mkdirSync(CACHE_DIR, { recursive: true });
 
+  // Starts now so the price download overlaps the ccusage runs below; estimates are
+  // built after they finish, and ensure() never throws or blocks for long.
+  const pricesReady = pricing.ensure();
+
   // Seed antigravity from disk cache immediately if available
   const diskAg = loadAntigravityFromDiskCache();
   if (diskAg && !inMemoryHarnessStore.has("antigravity")) {
@@ -624,6 +646,7 @@ async function runHarnessRefresh(options?: { forceDeepScan?: boolean }): Promise
     }
   }
 
+  await pricesReady;
   cachedDashboardPayload = buildDashboardPayloadFromStore();
   try {
     writeFileSync(DASHBOARD_CACHE_FILE, JSON.stringify(cachedDashboardPayload), "utf8");

package/src/logFile.ts

@@ -0,0 +1,37 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+
+// When the CLI starts the server in the background it has no terminal, so the server
+// writes its own output to the file named in TOKEN_LARPER_LOG_FILE (the CLI reads it
+// to learn the URL). Imported first by server.ts so nothing is missed.
+
+const file = process.env.TOKEN_LARPER_LOG_FILE;
+
+if (file) {
+  try {
+    writeFileSync(file, "");
+  } catch {
+    // Logging is best effort.
+  }
+  const write = (args: unknown[]) => {
+    try {
+      appendFileSync(file, args.map((a) => (a instanceof Error ? a.stack ?? a.message : String(a))).join(" ") + "\n");
+    } catch {
+      // Logging is best effort.
+    }
+  };
+  for (const level of ["log", "info", "warn", "error"] as const) {
+    const original = console[level].bind(console);
+    console[level] = (...args: unknown[]) => {
+      write(args);
+      original(...args);
+    };
+  }
+  process.on("uncaughtException", (error) => {
+    write(["Token Larper stopped:", error]);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    write(["Token Larper stopped:", reason]);
+    process.exit(1);
+  });
+}

package/src/pricing.ts

@@ -0,0 +1,210 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { dataPath } from "./paths.ts";
+
+// Model prices for the estimated cost. OpenRouter publishes a public price list that
+// tracks new models faster than a table kept in this repo. The one request goes to its
+// models endpoint (no key, no usage data sent) at most once a day; the result is cached
+// in the data folder and the built-in rates in ccusage.ts cover whatever it does not list.
+// Set TOKEN_LARPER_OFFLINE=1 to skip the request and use only the cache and built-in rates.
+
+/** USD per 1M tokens: input, output, cache write, cache read. */
+export type Rates = [input: number, output: number, cacheWrite: number, cacheRead: number];
+
+export type PriceTable = Map<string, Rates>;
+
+export interface OpenRouterModel {
+  id: string;
+  pricing?: Record<string, unknown>;
+}
+
+const MODELS_URL = "https://openrouter.ai/api/v1/models";
+const REFRESH_MS = 24 * 60 * 60 * 1000;
+const RETRY_MS = 15 * 60 * 1000;
+const TIMEOUT_MS = 8000;
+
+/**
+ * Reduces a model name to the form both ccusage and OpenRouter can be compared in:
+ * lower case, without the harness tag ("[pi] "), provider ("anthropic/") or variant
+ * (":free"), and with dashed versions dotted ("4-5" becomes "4.5").
+ */
+export function normalizeModelName(name: string): string {
+  const slug = name
+    .toLowerCase()
+    .trim()
+    .replace(/^\[[^\]]*\]\s*/, "")
+    .replace(/^.*\//, "")
+    .replace(/:.*$/, "");
+
+  const parts = slug.split("-");
+  const out: string[] = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]!;
+    const next = parts[i + 1];
+    // A pair of short numbers is a version ("opus-4-5"), unless it follows a year
+    // ("2024-11-20" is a date).
+    const followsYear = /^\d{4}$/.test(parts[i - 1] ?? "");
+    if (next !== undefined && !followsYear && /^\d{1,2}$/.test(part) && /^\d{1,2}$/.test(next)) {
+      out.push(`${part}.${next}`);
+      i++;
+    } else {
+      out.push(part);
+    }
+  }
+  return out.join("-");
+}
+
+// Multiplying a per-token price by 1e6 leaves float noise (0.0000002 * 1e6 is
+// 0.19999999999999998).
+const perMillion = (perToken: number) => Number((perToken * 1e6).toPrecision(10));
+
+/** Absent or invalid is undefined; zero is a real price. */
+function cachePrice(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+
+/**
+ * Builds the rate table from OpenRouter's model list. Variants (":free" is $0, ":batch"
+ * is half price) and "~...-latest" aliases would misprice a model, and a price of 0 or
+ * -1 means free or variable, so none of those are kept. When two ids normalize to the
+ * same name, the first listed wins.
+ */
+export function buildPriceTable(models: readonly OpenRouterModel[]): PriceTable {
+  const table: PriceTable = new Map();
+  for (const model of models) {
+    if (typeof model?.id !== "string" || model.id.startsWith("~") || model.id.includes(":")) continue;
+    const input = Number(model.pricing?.prompt);
+    const output = Number(model.pricing?.completion);
+    if (!(input > 0) || !(output > 0)) continue;
+
+    const key = normalizeModelName(model.id);
+    if (!key || table.has(key)) continue;
+
+    // Anthropic bills cache writes at 1.25x input and reads at 0.1x. Elsewhere a missing
+    // cache price means no discount is known, so cached tokens cost the input price.
+    const anthropic = model.id.startsWith("anthropic/");
+    const cacheWrite = cachePrice(model.pricing?.input_cache_write) ?? (anthropic ? input * 1.25 : input);
+    const cacheRead = cachePrice(model.pricing?.input_cache_read) ?? (anthropic ? input * 0.1 : input);
+    table.set(key, [perMillion(input), perMillion(output), perMillion(cacheWrite), perMillion(cacheRead)]);
+  }
+  return table;
+}
+
+/**
+ * The rates for a model name, or null if the table has none. An exact match wins;
+ * otherwise the longest listed name that prefixes it at a dash ("gpt-5.5-codex" finds
+ * "gpt-5.5", and "claude-opus-4-20250514" finds "claude-opus-4"). A prefix must end at
+ * a dash so "claude-opus-4.9" never borrows the price of "claude-opus-4".
+ */
+export function lookupRates(modelName: string, table: PriceTable): Rates | null {
+  const key = normalizeModelName(modelName);
+  if (!key) return null;
+
+  const exact = table.get(key);
+  if (exact) return exact;
+
+  let best: string | undefined;
+  for (const listed of table.keys()) {
+    if (key.startsWith(`${listed}-`) && (!best || listed.length > best.length)) best = listed;
+  }
+  return best ? table.get(best)! : null;
+}
+
+const isRates = (value: unknown): value is Rates =>
+  Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0);
+
+export interface PricingOptions {
+  cacheFile?: string;
+  fetchImpl?: (url: string, init?: RequestInit) => Promise<Response>;
+  now?: () => number;
+}
+
+export function createPricing(options: PricingOptions = {}) {
+  const cacheFile = options.cacheFile ?? dataPath("openrouter-pricing.json");
+  const doFetch = options.fetchImpl ?? fetch;
+  const now = options.now ?? Date.now;
+
+  let table: PriceTable = new Map();
+  // The same few model names repeat across every daily row, and an unlisted name scans
+  // the whole table, so answers are remembered until the table changes.
+  let answers = new Map<string, Rates | null>();
+  let fetchedAt = 0;
+  let nextAttempt = 0;
+  let cacheRead = false;
+  let inFlight: Promise<void> | null = null;
+
+  function setTable(next: PriceTable): void {
+    table = next;
+    answers = new Map();
+  }
+
+  function readCache(): void {
+    try {
+      const stored = JSON.parse(readFileSync(cacheFile, "utf8")) as { fetchedAt?: unknown; rates?: Record<string, unknown> };
+      const rates: PriceTable = new Map();
+      for (const [key, value] of Object.entries(stored.rates ?? {})) if (isRates(value)) rates.set(key, value);
+      if (typeof stored.fetchedAt === "number" && rates.size > 0) {
+        setTable(rates);
+        fetchedAt = stored.fetchedAt;
+      }
+    } catch {
+      // No cache yet, or it is unreadable; the next download replaces it.
+    }
+  }
+
+  async function download(): Promise<void> {
+    try {
+      const res = await doFetch(MODELS_URL, { signal: AbortSignal.timeout(TIMEOUT_MS), headers: { Accept: "application/json" } });
+      if (!res.ok) throw new Error(`OpenRouter responded ${res.status}`);
+      const body = (await res.json()) as { data?: unknown };
+      if (!Array.isArray(body.data)) throw new Error("OpenRouter response had no model list");
+
+      const fresh = buildPriceTable(body.data);
+      // An empty list would wipe good prices, so treat it as a failed download.
+      if (fresh.size === 0) throw new Error("OpenRouter response had no usable prices");
+
+      setTable(fresh);
+      fetchedAt = now();
+      try {
+        mkdirSync(dirname(cacheFile), { recursive: true });
+        writeFileSync(cacheFile, JSON.stringify({ fetchedAt, rates: Object.fromEntries(fresh) }), "utf8");
+      } catch {
+        // The in-memory prices still work when the disk is not writable.
+      }
+    } catch {
+      // Offline or the endpoint changed: keep what we have and try again later.
+      nextAttempt = now() + RETRY_MS;
+    }
+  }
+
+  return {
+    /** Rates from the OpenRouter table, or null when it has no price for this model. */
+    lookup(modelName: string): Rates | null {
+      let rates = answers.get(modelName);
+      if (rates === undefined) {
+        rates = lookupRates(modelName, table);
+        answers.set(modelName, rates);
+      }
+      return rates;
+    },
+
+    /** Replaces the in-memory table. */
+    use: setTable,
+
+    /** Loads the cached table, and downloads a new one if it is over a day old. Never throws. */
+    async ensure(): Promise<void> {
+      if (!cacheRead) {
+        cacheRead = true;
+        readCache();
+      }
+      if (process.env.TOKEN_LARPER_OFFLINE === "1") return;
+      if (now() - fetchedAt < REFRESH_MS || now() < nextAttempt) return;
+      inFlight ??= download().finally(() => (inFlight = null));
+      await inFlight;
+    },
+  };
+}
+
+export const pricing = createPricing();

package/src/server.ts

@@ -1,5 +1,6 @@
+import "./logFile.ts";
 import { join, resolve } from "node:path";
-import { getDashboardData } from "./ccusage.ts";
+import { getDashboardData, stopCcusageRuns } from "./ccusage.ts";
 import { getStartupStatus, repointStartupIfStale, setStartupStatus } from "./startup.ts";
 import { startSystemTray, stopSystemTray } from "./tray.ts";
 import { buildTrayStatus, parseTheme, saveTheme } from "./trayStatus.ts";
@@ -60,7 +61,7 @@ function openDashboard(port: number) {
       : process.platform === "darwin"
       ? `open http://localhost:${port}`
       : `xdg-open http://localhost:${port}`;
-  import("node:child_process").then(({ exec }) => exec(cmd));
+  import("node:child_process").then(({ exec }) => exec(cmd, { windowsHide: true }));
 }
 
 /** The version of a Token Larper already on the port, "0.0.0" for one too old to say, or null if none. */
@@ -82,6 +83,22 @@ async function runningVersion(port: number): Promise<string | null> {
   }
 }
 
+async function waitForPort(port: number, timeoutMs: number): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  let announced = false;
+  while (true) {
+    try {
+      Bun.serve({ port, hostname: "127.0.0.1", fetch: () => new Response() }).stop(true);
+      return true;
+    } catch {
+      if (Date.now() > deadline) return false;
+      if (!announced) console.log(`Waiting for port ${port} to be released...`);
+      announced = true;
+      await Bun.sleep(500);
+    }
+  }
+}
+
 // A newer copy (after an update, or a fresh npx run) replaces an older one on the
 // same port. The same or a newer version already running just gets opened.
 const running = await runningVersion(PORT);
@@ -98,6 +115,10 @@ if (running !== null && compareVersions(running, APP_VERSION) < 0) {
     // It may exit before answering.
   }
   for (let i = 0; i < 40 && (await runningVersion(PORT)) !== null; i++) await Bun.sleep(250);
+  // The old copy can stop answering before its port is free: on Windows, processes it
+  // started hold the socket until they exit. Wait for the port rather than moving to the
+  // next one, which the open dashboard isn't watching.
+  if (!(await waitForPort(PORT, 90_000))) console.warn(`Port ${PORT} is still taken after 90 s.`);
 } else if (running !== null) {
   console.log(`🔥 Token Larper is already running at http://localhost:${PORT}`);
   console.log(`🚀 Opening dashboard in your default browser...`);
@@ -231,8 +252,12 @@ function startServer(preferredPort: number) {
         return Response.json({ error: "This copy runs from a git checkout. Update it with git pull." }, { status: 409 });
       }
       try {
-        startUpdate(activePort);
-        return Response.json({ ok: true });
+        const status = await checkForUpdates();
+        if (!status.updateAvailable || !status.latest) {
+          return Response.json({ error: status.error ?? "Already on the latest version." }, { status: 409 });
+        }
+        startUpdate(activePort, status.latest);
+        return Response.json({ ok: true, version: status.latest });
       } catch (error) {
         return Response.json({ error: error instanceof Error ? error.message : "Could not start the update" }, { status: 500 });
       }
@@ -240,6 +265,7 @@ function startServer(preferredPort: number) {
 
     if (url.pathname === "/api/shutdown" && req.method === "POST") {
       setTimeout(() => {
+        stopCcusageRuns();
         stopSystemTray();
         server.stop(true);
         process.exit(0);
@@ -266,13 +292,12 @@ const server = startServer(PORT);
 startSystemTray(server.port ?? PORT);
 void repointStartupIfStale();
 
-process.on("SIGINT", () => {
-  stopSystemTray();
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  stopSystemTray();
-  process.exit(0);
-});
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => {
+    stopCcusageRuns();
+    stopSystemTray();
+    process.exit(0);
+  });
+}
 
 console.log(`🔥 Token Larper running at http://localhost:${server.port} (System Tray Icon Active)`);

package/src/startup.ts

@@ -42,7 +42,7 @@ function saveSettings(settings: SavedSettings): void {
 }
 
 async function runReg(args: string[]): Promise<{ code: number; output: string; error: string }> {
-  const proc = Bun.spawn(["reg.exe", ...args], { stdout: "pipe", stderr: "pipe" });
+  const proc = Bun.spawn(["reg.exe", ...args], { stdout: "pipe", stderr: "pipe", windowsHide: true });
   const [output, error, code] = await Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),

package/src/tray.ts

@@ -444,6 +444,7 @@ export async function startSystemTray(port: number): Promise<void> {
       {
         stdout: "pipe",
         stderr: "ignore",
+        windowsHide: true,
       }
     );
     const out = (await new Response(proc.stdout).text()).trim();
@@ -462,6 +463,7 @@ export function stopSystemTray(): void {
       Bun.spawnSync(["taskkill.exe", "/PID", String(trayPid), "/F"], {
         stdout: "ignore",
         stderr: "ignore",
+        windowsHide: true,
       });
     } catch {
       // ignore

package/src/updates.ts

@@ -48,15 +48,39 @@ export async function checkForUpdates(force = false): Promise<UpdateStatus> {
 }
 
 /**
- * Start the latest version in the background. The new copy sees this server running
- * an older version, asks it to shut down, and takes over the same port (bin/cli.js).
+ * Run a program in the background, independent of this server.
+ *
+ * On Windows every child of this server inherits its listening socket, which keeps the
+ * port taken until the child exits. Start-Process launches the program through the shell
+ * instead, so it inherits nothing, and gives it a hidden console that anything it starts
+ * shares instead of opening windows of their own. Arguments must not contain double quotes.
  */
-export function startUpdate(port: number): void {
-  const child = spawn(process.execPath, ["x", `${PACKAGE}@latest`], {
-    detached: true,
-    stdio: "ignore",
-    windowsHide: true,
-    env: { ...process.env, PORT: String(port), TOKEN_LARPER_NO_BROWSER: "1" },
+export function launchIndependent(program: string, args: string[], env: Record<string, string | undefined>): void {
+  if (process.platform === "win32") {
+    const quote = (value: string) => `'${value.replace(/'/g, "''")}'`;
+    const command = `Start-Process -WindowStyle Hidden -FilePath ${quote(program)} -ArgumentList ${args.map((a) => quote(`"${a}"`)).join(",")}`;
+    // Not detached: a PowerShell without any console fails to start the program.
+    spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+      stdio: "ignore",
+      windowsHide: true,
+      env,
+    }).unref();
+    return;
+  }
+  spawn(program, args, { detached: true, stdio: "ignore", env }).unref();
+}
+
+/**
+ * Start the given version in the background. The new copy sees this server running an
+ * older version, asks it to shut down, and takes over the same port (src/server.ts).
+ * The exact version is installed because `@latest` can resolve from bun's cached
+ * package list and bring back the version already running.
+ */
+export function startUpdate(port: number, version: string): void {
+  if (!/^\d+\.\d+\.\d+(?:-[\w.]+)?$/.test(version)) throw new Error(`Unexpected version "${version}"`);
+  launchIndependent(process.execPath, ["x", `${PACKAGE}@${version}`], {
+    ...process.env,
+    PORT: String(port),
+    TOKEN_LARPER_NO_BROWSER: "1",
   });
-  child.unref();
 }