atom-agent 0.3.0

package/dist/auth.js

@@ -0,0 +1,122 @@
+// Auth store mirroring opencode's auth.json (manual-key only).
+// Credentials in ~/.atom/auth.json shaped:
+//   {version:1, providers:{"<id>":{apiKey, baseURL?}}}
+// 0600 perms on POSIX via chmod; best-effort on Windows.
+// Key resolution per provider: standard env var wins when set, else stored.
+// Env names: OPENCODE_ZEN_API_KEY (zen), OPENAI_API_KEY, ANTHROPIC_API_KEY,
+// DEEPSEEK_API_KEY, MISTRAL_API_KEY, GEMINI_API_KEY (also GOOGLE_API_KEY
+// alias). openai-compatible: stored key + stored baseURL only.
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getProvider } from "./providers.js";
+export const AUTH_VERSION = 1;
+export function homeDir() {
+    return (process.env.ATOM_HOME ??
+        process.env.HOME ??
+        process.env.USERPROFILE ??
+        os.homedir());
+}
+export function atomDir(home) {
+    return path.join(home ?? homeDir(), ".atom");
+}
+export function authFilePath(home) {
+    return path.join(atomDir(home), "auth.json");
+}
+export function emptyAuth() {
+    return { version: AUTH_VERSION, providers: {} };
+}
+// Load auth.json; missing/corrupt file yields empty auth (never throws).
+export function loadAuth(home) {
+    try {
+        const p = authFilePath(home);
+        if (!existsSync(p))
+            return emptyAuth();
+        const raw = readFileSync(p, "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data !== "object" || data === null)
+            return emptyAuth();
+        const o = data;
+        const providers = {};
+        const src = o["providers"];
+        if (typeof src === "object" && src !== null) {
+            for (const [k, v] of Object.entries(src)) {
+                if (typeof v !== "object" || v === null)
+                    continue;
+                const e = v;
+                if (typeof e["apiKey"] !== "string")
+                    continue;
+                const entry = { apiKey: e["apiKey"] };
+                if (typeof e["baseURL"] === "string" && e["baseURL"].length > 0) {
+                    entry.baseURL = e["baseURL"];
+                }
+                providers[k] = entry;
+            }
+        }
+        return { version: AUTH_VERSION, providers };
+    }
+    catch {
+        return emptyAuth();
+    }
+}
+// Save auth.json (mkdir -p + 0600 on POSIX, best-effort on Windows).
+export function saveAuth(auth, home) {
+    const dir = atomDir(home);
+    mkdirSync(dir, { recursive: true });
+    const p = path.join(dir, "auth.json");
+    const payload = { version: AUTH_VERSION, providers: auth.providers ?? {} };
+    writeFileSync(p, JSON.stringify(payload, null, 2) + "\n", "utf8");
+    try {
+        chmodSync(p, 0o600);
+    }
+    catch {
+        // best-effort on Windows; ignore
+    }
+}
+export function getStoredAuth(auth, id) {
+    return auth.providers[id];
+}
+export function getStoredKey(auth, id) {
+    return auth.providers[id]?.apiKey ?? "";
+}
+export function getStoredBaseURL(auth, id) {
+    return auth.providers[id]?.baseURL ?? "";
+}
+// Env key for a provider (first non-empty env var wins). Empty when none.
+export function getEnvKey(id) {
+    const def = getProvider(id);
+    if (!def)
+        return "";
+    for (const name of def.envVars) {
+        const v = process.env[name];
+        if (typeof v === "string" && v.length > 0)
+            return v;
+    }
+    return "";
+}
+// Resolved key: env wins when set, else stored. openai-compatible has no
+// env vars, so it is stored-only by construction.
+export function resolveApiKey(id, auth) {
+    return getEnvKey(id) || getStoredKey(auth, id);
+}
+export function hasKey(id, auth) {
+    return resolveApiKey(id, auth).length > 0;
+}
+// Set (or replace) the stored key for a provider; returns the updated auth.
+export function setStoredKey(auth, id, apiKey, baseURL) {
+    const next = {
+        version: AUTH_VERSION,
+        providers: { ...auth.providers },
+    };
+    const prev = next.providers[id];
+    const entry = { apiKey };
+    const base = baseURL !== undefined ? baseURL : prev?.baseURL;
+    if (typeof base === "string" && base.length > 0)
+        entry.baseURL = base;
+    next.providers[id] = entry;
+    return next;
+}
+export function setStoredBaseURL(auth, id, baseURL) {
+    const prev = auth.providers[id];
+    return setStoredKey(auth, id, prev?.apiKey ?? "", baseURL);
+}

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./App.js";
+import { DEFAULT_ENDPOINT, DEFAULT_MODEL, endpointConfig, } from "./zen.js";
+import { loadAuth, resolveApiKey } from "./auth.js";
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+    console.log(`Atom chatbot (Ink TUI)
+Usage: npm start
+Env:
+  OPENCODE_ZEN_API_KEY  optional when ~/.atom/auth.json has a zen key (get one at https://opencode.ai/auth)
+  OPENAI_API_KEY / ANTHROPIC_API_KEY / DEEPSEEK_API_KEY / MISTRAL_API_KEY / GEMINI_API_KEY (GOOGLE_API_KEY alias)  optional per provider (env wins over stored)
+  OPENCODE_ZEN_MODEL    optional (default: ${DEFAULT_MODEL})
+  OPENCODE_ZEN_ENDPOINT optional (default: ${DEFAULT_ENDPOINT})
+Commands: /model (model picker) | /provider (provider + key picker) | /effort (reasoning-effort picker) | /tools | /skills (list installed skills) | /mode | /yolo (toggle) | /plan (read-only plan mode) | /clear | /resume (restore last saved session) | /help | /exit | /quit
+Providers: opencode-zen/openai/anthropic/deepseek/mistral/google-gemini/openai-compatible (keys in ~/.atom/auth.json, 0600 POSIX; use /provider to paste one).
+Note: reasoning_effort is sent only for opencode-zen supported models.`);
+    process.exit(0);
+}
+const { endpoint, apiKey: envKey, model } = endpointConfig();
+// Stored zen key (from a previous /provider paste) applies when no env key.
+const storedZen = resolveApiKey("opencode-zen", loadAuth());
+const apiKey = envKey || storedZen;
+// Always start the TUI (even without a key) so /provider can paste one.
+// Chatting without a key for the active provider errors inline with a
+// /provider pointer; nothing is POSTed.
+render(_jsx(App, { apiKey: apiKey, endpoint: endpoint, initialModel: model }));

package/dist/compact.js

@@ -0,0 +1,277 @@
+// Context compaction (Claude-Code/opencode-style) for the Ink chatbot.
+// AUTO-COMPACT at ~83% of the model's verified context window plus manual
+// `/compact [focus]` (see App.tsx slash registry).
+//
+// Mechanics mirrored from research (verified this session):
+// - Claude Code: auto-compact = ONE extra request (same system prompt +
+//   tools + history, summarization instruction appended); history replaced
+//   by the summary; manual `/compact [focus]`; thrashing guard.
+// - opencode V2: preflight estimate = JSON-serialized request size at
+//   4 chars/token; summary via session model with TOOLS DISABLED, ≤4096
+//   output tokens, structured template; newest tail retained (~8000 tokens,
+//   tool outputs capped 2000 chars); overflow-recovery retry once.
+//
+// This module is pure + testable (mocked fetch only in tests, never live).
+// The App owns session refs (load/streak/disabled/pending) and the atomic
+// swap + save; this module owns math, splitting, instruction, and the
+// summary POST (tools disabled, 4096 cap).
+import { contextWindowFor } from "./context-windows.js";
+import { historyChars, messageChars, chatCompletionForProvider, } from "./zen.js";
+// ---- Constants ----
+export const COMPACT_PCT_DEFAULT = 0.83;
+export const COMPACT_KEEP_TOKENS = 8000;
+export const COMPACT_SUMMARY_MAX_TOKENS = 4096;
+export const COMPACT_TOOL_OUTPUT_CAP = 2000;
+// opencode's 4ch/token heuristic (V2 preflight estimate): chars/4 floors to
+// estimated tokens. Used for load fallback + tail split only, never for the
+// `token: n/a` honesty rule or the NK cumulative spend.
+export const COMPACT_CHARS_PER_TOKEN = 4;
+export const COMPACT_THRASH_LIMIT = 3;
+// ---- Threshold ----
+function clampPctPercent(n) {
+    return Math.min(Math.max(n, 50), 95) / 100;
+}
+// Auto-compact threshold as a fraction (default 0.83). Env ATOM_COMPACT_PCT
+// is a percent (e.g. "83"), clamped 50–95; invalid/unset → default.
+export function compactPct() {
+    const raw = process.env.ATOM_COMPACT_PCT;
+    if (raw === undefined)
+        return COMPACT_PCT_DEFAULT;
+    const text = raw.trim();
+    if (!/^\d+(\.\d+)?$/.test(text))
+        return COMPACT_PCT_DEFAULT;
+    const n = Number(text);
+    if (!Number.isFinite(n))
+        return COMPACT_PCT_DEFAULT;
+    return clampPctPercent(n);
+}
+// ---- Load metric ----
+export function estimateTokensForChars(chars) {
+    // opencode's 4ch/token heuristic.
+    const c = Number.isFinite(chars) && chars > 0 ? Math.floor(chars) : 0;
+    return Math.floor(c / COMPACT_CHARS_PER_TOKEN);
+}
+// Load = last POST's reported prompt_tokens when available, else the
+// 4ch/token estimate of the sent history chars.
+export function computeContextLoad(lastPromptTokens, sentHistoryChars) {
+    if (typeof lastPromptTokens === "number" &&
+        Number.isFinite(lastPromptTokens) &&
+        lastPromptTokens >= 0) {
+        return Math.floor(lastPromptTokens);
+    }
+    return estimateTokensForChars(sentHistoryChars);
+}
+export function shouldAutoCompact(load, model, pctOverride) {
+    const window = contextWindowFor(model);
+    if (window === undefined)
+        return false; // never invent a window
+    const pct = typeof pctOverride === "number" && Number.isFinite(pctOverride)
+        ? pctOverride
+        : compactPct();
+    return load / window >= pct;
+}
+// ---- Turn helpers ----
+export function countUserTurns(history) {
+    let n = 0;
+    for (const m of history) {
+        if (m?.role === "user")
+            n += 1;
+    }
+    return n;
+}
+function turnStarts(history) {
+    const starts = [];
+    for (let i = 1; i < history.length; i++) {
+        if (history[i]?.role === "user")
+            starts.push(i);
+    }
+    return starts;
+}
+function turnEnd(history, startIdx, starts) {
+    const pos = starts.indexOf(startIdx);
+    if (pos < 0)
+        return history.length;
+    return pos + 1 < starts.length ? starts[pos + 1] : history.length;
+}
+function turnChars(history, start, end) {
+    let n = 0;
+    for (let i = start; i < end; i++)
+        n += messageChars(history[i]);
+    return n;
+}
+export function capToolOutputsInTail(tail) {
+    return tail.map((m) => {
+        if (m.role === "tool" && typeof m.content === "string" && m.content.length > COMPACT_TOOL_OUTPUT_CAP) {
+            return {
+                ...m,
+                content: m.content.slice(0, COMPACT_TOOL_OUTPUT_CAP) +
+                    "\n[truncated: tool output exceeded 2000 chars]",
+            };
+        }
+        return { ...m };
+    });
+}
+// Split history (after system) into head + retained newest tail of whole
+// user-turns up to KEEP_TOKENS estimated tokens (chars/4). Tool outputs in
+// the tail are capped at 2000 chars each. Never drops history[0]; always
+// keeps at least the newest turn; when everything fits but there is more
+// than one turn, keeps only the newest turn in the tail so manual /compact
+// still has an older turn to summarize.
+export function splitHistoryForCompaction(history, keepTokens = COMPACT_KEEP_TOKENS) {
+    if (history.length <= 1)
+        return { head: [], tail: [], olderTurnCount: 0 };
+    const starts = turnStarts(history);
+    if (starts.length === 0)
+        return { head: [], tail: [], olderTurnCount: 0 };
+    let totalChars = 0;
+    let tailStart = starts[starts.length - 1];
+    for (let s = starts.length - 1; s >= 0; s--) {
+        const start = starts[s];
+        const end = turnEnd(history, start, starts);
+        totalChars += turnChars(history, start, end);
+        const est = estimateTokensForChars(totalChars);
+        if (est <= keepTokens) {
+            tailStart = start;
+        }
+        else {
+            break;
+        }
+    }
+    // Everything fits but >1 turn: keep only the newest turn in the tail so
+    // manual /compact still has an older turn to summarize (auto never
+    // reaches here — its load would be far below threshold when everything
+    // fits in 8000 tokens).
+    if (tailStart === starts[0] && starts.length > 1) {
+        tailStart = starts[starts.length - 1];
+    }
+    const head = history.slice(1, tailStart);
+    const rawTail = history.slice(tailStart);
+    const tail = capToolOutputsInTail(rawTail);
+    let olderTurnCount = 0;
+    for (const m of head)
+        if (m?.role === "user")
+            olderTurnCount += 1;
+    return { head, tail, olderTurnCount };
+}
+// ---- Instruction template ----
+export function buildCompactionInstruction(focusText) {
+    const focus = typeof focusText === "string" && focusText.trim().length > 0
+        ? `\nFocus for this summary: ${focusText.trim()}\n`
+        : "";
+    return (`Summarize the conversation so far for context compaction. Be concise but preserve all information needed to continue the work without re-reading the full history.` +
+        `${focus}\n` +
+        `Structure your summary with these headings (omit a section only when it has no content):\n` +
+        `## Objective\n` +
+        `## Requirements\n` +
+        `## Decisions\n` +
+        `## Completed work\n` +
+        `## Active work\n` +
+        `## Blockers\n` +
+        `## Next moves\n` +
+        `## Relevant files\n` +
+        `Rules: no tools are available for this request — answer with the summary text only, no tool calls, no preamble beyond the headings.`);
+}
+export function buildSummaryMessages(systemContent, head, focusText) {
+    return [
+        { role: "system", content: systemContent },
+        ...head.map((m) => ({ ...m })),
+        { role: "user", content: buildCompactionInstruction(focusText) },
+    ];
+}
+export function buildCompactedHistory(systemMessage, summaryText, tail, olderTurnCount, nowISO) {
+    const iso = nowISO ?? new Date().toISOString();
+    const summaryUser = {
+        role: "user",
+        content: `[Compacted context ${iso}: summary of ${olderTurnCount} older turns]\n${summaryText}`,
+    };
+    return [
+        { ...systemMessage },
+        summaryUser,
+        ...tail.map((m) => ({ ...m })),
+    ];
+}
+export function compactBoundaryLine(olderTurnCount) {
+    return `(context compacted: ${olderTurnCount} turns → summary)`;
+}
+// ---- Thrash guard ----
+export function isThrashDisabled(streak) {
+    return streak >= COMPACT_THRASH_LIMIT;
+}
+// ---- Size-error detection + head truncation for the once-retry ----
+export function isSizeError(e) {
+    const msg = e instanceof Error ? e.message : String(e ?? "");
+    if (/HTTP\s+(400|413)\b/.test(msg))
+        return true;
+    return /context|too long|maximum|too many|overflow|too large|token[^.]{0,40}limit|length|exceed/i.test(msg);
+}
+// Truncate head to budget ONCE: drop the oldest half of its user-turns,
+// preserving assistant/tool pairing (turn boundaries).
+export function truncateHeadForRetry(head) {
+    if (head.length <= 1)
+        return [...head];
+    const starts = [];
+    for (let i = 0; i < head.length; i++) {
+        if (head[i]?.role === "user")
+            starts.push(i);
+    }
+    if (starts.length <= 1) {
+        // No turn structure: keep the newest half of messages.
+        return head.slice(Math.ceil(head.length / 2));
+    }
+    const keepTurns = Math.max(1, Math.ceil(starts.length / 2));
+    const keepFrom = starts[starts.length - keepTurns];
+    return head.slice(keepFrom);
+}
+// Summary POST: SAME provider/model via the existing chat path but TOOLS
+// DISABLED (no `tools` key in the POST body) and output capped at 4096
+// (max_tokens/maxOutputTokens per kind — see zen.ts/adapters.ts). Returns
+// the summary text. On size-overflow it truncates head to budget ONCE and
+// retries once, then gives up with a `/clear` suggestion; other failures
+// throw immediately with history untouched (caller must not swap).
+export async function requestCompactSummary(req) {
+    const attempt = async (head) => {
+        const messages = buildSummaryMessages(req.systemContent, head, req.focusText);
+        const res = await chatCompletionForProvider(req.provider, req.apiKey, req.model, messages, {
+            baseURL: req.baseURL,
+            endpointOverride: req.endpointOverride,
+            disableTools: true,
+            maxOutputTokens: COMPACT_SUMMARY_MAX_TOKENS,
+            ...(req.signal ? { signal: req.signal } : {}),
+        });
+        // Totals keep accumulating: forward real summary usage when present.
+        // The caller must NOT feed this into lastPromptTokens (load tracks the
+        // main context, not the head-sized summary request).
+        if (res.usage !== undefined) {
+            try {
+                req.onUsage?.(res.usage);
+            }
+            catch {
+                // observer errors never break compaction
+            }
+        }
+        const text = (res.content ?? "").trim();
+        if (!text)
+            throw new Error("Empty reply from model (unexpected payload).");
+        return text;
+    };
+    try {
+        return await attempt(req.head);
+    }
+    catch (e) {
+        if (!isSizeError(e))
+            throw e;
+        // Overflow/fails-from-size: truncate head to budget ONCE and retry once.
+        if (req.head.length <= 1) {
+            throw new Error(`${e instanceof Error ? e.message : String(e)} (compact failed — use /clear)`);
+        }
+        const truncated = truncateHeadForRetry(req.head);
+        try {
+            return await attempt(truncated);
+        }
+        catch (e2) {
+            throw new Error(`${e2 instanceof Error ? e2.message : String(e2)} (compact failed — use /clear)`);
+        }
+    }
+}
+// Re-export for callers that need the post-turn history size.
+export { historyChars };

package/dist/context-windows.js

@@ -0,0 +1,112 @@
+export const CONTEXT_WINDOWS = {
+    // DeepSeek V4 family: 1M context.
+    // Sources: https://www.deepseek.com/en/news/v4-preview/
+    // ("1M context is now the default"), https://arxiv.org/abs/2606.19348
+    // ("supporting a context length of one million tokens").
+    "deepseek-v4-pro": 1_000_000,
+    "deepseek-v4-flash": 1_000_000,
+    "deepseek-v4-flash-vision-exp": 1_000_000,
+    // Kimi K2.5 / K2.6: 256K context (262144 tokens).
+    // Sources: https://github.com/MoonshotAI/Kimi-K2.5 (Context Length 256K),
+    // https://huggingface.co/moonshotai/Kimi-K2.5 (Context Length 256K),
+    // https://platform.kimi.ai/docs/guide/kimi-k2-6-quickstart
+    // ("kimi-k2.7-code and kimi-k2.6 models both provide a 256K context window").
+    "kimi-k2.5": 262_144,
+    "kimi-k2.6": 262_144,
+    // Kimi K2.7 Code: 256K context.
+    // Source: https://www.kimi.com/code/docs/en/kimi-code/models.html
+    // (kimi-for-coding / K2.7 Code: 256k context window).
+    "kimi-k2.7-code": 262_144,
+    // Kimi K3: 1M context (1048576 tokens).
+    // Sources: https://github.com/MoonshotAI/Kimi-K3 (Context Length 1048576),
+    // https://docs.api.nvidia.com/nim/reference/moonshotai-kimi-k3
+    // (Input Context Length: 1,048,576 tokens).
+    "kimi-k3": 1_048_576,
+    // GLM-5.1: 200K context.
+    // Sources: https://llm-stats.com/models/compare/glm-5.1-vs-glm-5.3
+    // (GLM-5.1: 200,000 tokens), https://z.ai/blog/glm-5.1
+    // (eval settings "with a 200K context window").
+    "glm-5.1": 200_000,
+    // GLM-5.2: solid 1M context.
+    // Source: https://z.ai/blog/glm-5.2 ("a solid 1M-token context").
+    "glm-5.2": 1_000_000,
+    // GLM-5.3: 1M context.
+    // Sources: https://docs.aimlapi.com/api-references/text-models-llm/zhipu/glm-5.3
+    // ("1M-token context window"), https://kie.ai/blog/what-is-glm-5-3
+    // ("Context window 1M tokens").
+    "glm-5.3": 1_000_000,
+    // MiniMax M2.5 / M2.7: 204800 context; MiniMax M3: 1M context.
+    // Sources: https://platform.minimax.io/docs/guides/text-generation
+    // (context-window table: M3 1,000,000; M2.7/M2.5 204,800),
+    // https://www.minimax.io/models/text/m3 ("up to 1M tokens context window").
+    "minimax-m2.5": 204_800,
+    "minimax-m2.7": 204_800,
+    "minimax-m3": 1_000_000,
+    // OpenAI flagship chat models: 1.05M context window.
+    // Source: https://platform.openai.com/docs/models (Context window 1.05M
+    // for GPT-6 Astra, GPT-5.6 Sol/Terra/Luna).
+    "gpt-6-astra": 1_050_000,
+    "gpt-5.6-sol": 1_050_000,
+    "gpt-5.6-terra": 1_050_000,
+    "gpt-5.6-luna": 1_050_000,
+    // Anthropic Claude: 1M context (Opus 5 / Sonnet 5 / Fable 5.1),
+    // 200K for Haiku 4.5.
+    // Source: https://platform.claude.com/docs/en/models/overview
+    // (Context window row: 1M tokens / 1M tokens / 1M tokens / 200K tokens).
+    "claude-fable-5-1": 1_000_000,
+    "claude-opus-5": 1_000_000,
+    "claude-sonnet-5": 1_000_000,
+    "claude-haiku-4-5": 200_000,
+    "claude-haiku-4-5-20251001": 200_000,
+    // Google Gemini 3 family: 1M context (1,048,576 tokens).
+    // Sources: https://ai.google.dev/gemini-api/docs/gemini-3
+    // (Context Window 1M), https://ai.google.dev/gemini-api/docs/long-context
+    // ("large context windows of 1 million or more tokens"),
+    // https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/gemini/3-7-flash
+    // (Context window 1,048,576).
+    "gemini-3-flash-preview": 1_048_576,
+    "gemini-3.1-pro-preview": 1_048_576,
+    "gemini-3.1-flash-lite": 1_048_576,
+    "gemini-3.5-flash": 1_048_576,
+    "gemini-3.7-flash": 1_048_576,
+    "gemini-3.8-flash": 1_048_576,
+};
+// Context window for a model id, or undefined when the model has no
+// verified window (callers render the bare `token: NK` form).
+export function contextWindowFor(model) {
+    return CONTEXT_WINDOWS[model];
+}
+// Total session tokens: prefer usage.total_tokens when present, else
+// prompt_tokens + completion_tokens (missing keys count as 0).
+export function totalTokens(usage) {
+    if (typeof usage.total_tokens === "number") {
+        return Math.max(0, Math.floor(usage.total_tokens));
+    }
+    const prompt = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
+    const completion = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
+    return Math.max(0, Math.floor(prompt + completion));
+}
+// Footer token segment, EXACT format:
+// - no usage reported yet: `token: n/a` (never estimated)
+// - known window: `token: (P%) NK` (NK = round(total/1024) + "K" from the
+//   CUMULATIVE session spend; P = round(100*load/window) from the CURRENT
+//   context load — prompt_tokens of the last POST, else the 4ch/token
+//   estimate. Cumulative spend keeps growing after compaction, so it must
+//   NOT drive P; load does. Pass load explicitly; when omitted it falls
+//   back to the cumulative total for backward compat.)
+// - unknown window: `token: NK` (never invent a window)
+// Zero usage with a known window is `token: (0%) 0K`; without one `token: 0K`.
+export function formatTokenSegment(usage, model, load) {
+    if (!usage)
+        return "token: n/a";
+    const total = totalTokens(usage);
+    const k = `${Math.round(total / 1024)}K`;
+    const window = contextWindowFor(model);
+    if (window === undefined)
+        return `token: ${k}`;
+    const loadTokens = typeof load === "number" && Number.isFinite(load) && load >= 0
+        ? Math.floor(load)
+        : total;
+    const pct = Math.round((100 * loadTokens) / window);
+    return `token: (${pct}%) ${k}`;
+}