@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.100

package/dist/core/context/watcher.js

@@ -1,5 +1,5 @@
 /**
- * chokidar-based filewatch - α6.5 Phase 1 (three-tier context).
+ * chokidar-based filewatch - Phase 1 (three-tier context).
  *
  * The REPL needs a live signal when files change so the operator's
  * agent can re-read a stale file, and so the status bar can surface a
@@ -8,35 +8,35 @@
  *
  * Design choices:
  *
- *   1. **Ignore-aware**: every watched path is filtered through the
- *      same `PugiIgnore` matcher the skeleton walker uses. We pass the
- *      matcher into chokidar's `ignored` option so `node_modules/`,
- *      `dist/`, `.git/`, and secret files are never watched at all -
- *      this matters because chokidar's resource bound is the number
- *      of watched paths, not the number of total files in the repo.
+ *  1. **Ignore-aware**: every watched path is filtered through the
+ *     same `PugiIgnore` matcher the skeleton walker uses. We pass the
+ *     matcher into chokidar's `ignored` option so `node_modules/`,
+ *     `dist/`, `.git/`, and secret files are never watched at all -
+ *     this matters because chokidar's resource bound is the number
+ *     of watched paths, not the number of total files in the repo.
  *
- *   2. **Throttle**: chokidar can fire dozens of `change` events when
- *      a code formatter rewrites a directory. We batch events in a
- *      `THROTTLE_WINDOW_MS` window and emit a single aggregated event
- *      so the REPL system line / status bar do not flicker.
+ *  2. **Throttle**: chokidar can fire dozens of `change` events when
+ *     a code formatter rewrites a directory. We batch events in a
+ *     `THROTTLE_WINDOW_MS` window and emit a single aggregated event
+ *     so the REPL system line / status bar do not flicker.
  *
- *   3. **Watch cap**: per spec, the watcher caps watched paths at
- *      `MAX_WATCHED_PATHS`. Once the count crosses the cap we close
- *      the watcher and fall back to "no live updates this session" -
- *      better to silently lose the badge than to consume thousands of
- *      file descriptors. The fallback path emits one warning event so
- *      the operator knows live updates are off.
+ *  3. **Watch cap**: per spec, the watcher caps watched paths at
+ *     `MAX_WATCHED_PATHS`. Once the count crosses the cap we close
+ *     the watcher and fall back to "no live updates this session" -
+ *     better to silently lose the badge than to consume thousands of
+ *     file descriptors. The fallback path emits one warning event so
+ *     the operator knows live updates are off.
  *
- *   4. **Lifecycle**: `start()` is async (chokidar's `ready` event)
- *      so the caller can `await` the initial scan. `close()` is also
- *      async (chokidar's close is async). The watcher is reusable
- *      across multiple `start` / `close` pairs, but Phase 1 expects
- *      one-watcher-per-REPL-session.
+ *  4. **Lifecycle**: `start()` is async (chokidar's `ready` event)
+ *     so the caller can `await` the initial scan. `close()` is also
+ *     async (chokidar's close is async). The watcher is reusable
+ *     across multiple `start` / `close` pairs, but Phase 1 expects
+ *     one-watcher-per-REPL-session.
  *
- *   5. **Testability**: the chokidar handle is injectable via the
- *      `watchFactory` option. Production wires `chokidar.watch`;
- *      tests pass a fake emitter that lets the spec drive `add` /
- *      `change` / `unlink` events synchronously.
+ *  5. **Testability**: the chokidar handle is injectable via the
+ *     `watchFactory` option. Production wires `chokidar.watch`;
+ *     tests pass a fake emitter that lets the spec drive `add` /
+ *     `change` / `unlink` events synchronously.
  */
 import { EventEmitter } from 'node:events';
 import chokidar from 'chokidar';
@@ -50,7 +50,7 @@ export const THROTTLE_WINDOW_MS = 250;
  * giant subtree post-ready can blow past the cap without ever
  * re-evaluating. Sample every N adds so the cap fires within a
  * bounded window even on post-ready growth. Cheap: one Map
- * iteration per N adds. triple-review P2 (PR #380).
+ * iteration per N adds. triple-review P2 (PR).
  */
 export const CAP_CHECK_ADD_INTERVAL = 1_000;
 /**
@@ -76,7 +76,7 @@ export class PugiWatcher extends EventEmitter {
     /**
      * Counter of `add` events received since the last cap-check sample.
      * When it crosses CAP_CHECK_ADD_INTERVAL we schedule another check.
-     * Resets on every cap-check run. triple-review P2 (PR #380).
+     * Resets on every cap-check run. triple-review P2 (PR).
      */
     addsSinceLastCapCheck = 0;
     constructor(options) {
@@ -97,7 +97,7 @@ export class PugiWatcher extends EventEmitter {
         // the event so emit() does not crash the CLI; any real consumer
         // that subscribes later receives the events as normal because
         // EventEmitter delivers to every registered listener, not just one.
-        // Codex P1 (PR #380).
+        // Codex P1 (PR).
         this.on('error', () => {
             /* defensive no-op so emit('error') never throws */
         });
@@ -162,7 +162,7 @@ export class PugiWatcher extends EventEmitter {
                 // post-ready burst (e.g. `git checkout` of a giant subtree)
                 // does not silently blow past the watched-paths cap. The
                 // ready-time check is preserved; this is the missing follow-up
-                // sampler the comment promised. triple-review P2 (PR #380).
+                // sampler the comment promised. triple-review P2 (PR).
                 this.addsSinceLastCapCheck += 1;
                 if (this.addsSinceLastCapCheck >= CAP_CHECK_ADD_INTERVAL) {
                     this.addsSinceLastCapCheck = 0;
@@ -225,7 +225,7 @@ export class PugiWatcher extends EventEmitter {
         return this.buffer.length;
     }
     /* ------------------------------------------------------------ */
-    /* Internals                                                    */
+    /* Internals                                                   */
     /* ------------------------------------------------------------ */
     queue(kind, path) {
         if (this.closed)
@@ -291,7 +291,7 @@ export class PugiWatcher extends EventEmitter {
     }
 }
 /* ------------------------------------------------------------------ */
-/* Helpers                                                            */
+/* Helpers                                                           */
 /* ------------------------------------------------------------------ */
 /**
  * Convert an absolute path to a repo-relative POSIX path. chokidar

package/dist/core/context/working-set.js

@@ -1,41 +1,41 @@
 /**
- * Tier 1 working-set tracker - α6.5 Phase 1 (three-tier context).
+ * Tier 1 working-set tracker - Phase 1 (three-tier context).
  *
  * The model context window is finite. Tier 0 (repo skeleton, ~5KB) is
- * always loaded; Tier 2 (RAG, Anvil-side, deferred to α6.5b) answers
+ * always loaded; Tier 2 (RAG, Anvil-side, deferred to ) answers
  * queries on demand. Tier 1 - the working set - lives between them: the
  * subset of files the agent has touched THIS session, bounded so a
  * long REPL session does not unbounded-grow the system prompt.
  *
  * Design choices:
  *
- *   1. **LRU semantics**: the most-recently-touched file stays in the
- *      window; the oldest is evicted when the cap is hit. We use a
- *      `Map` so insertion order doubles as recency order (delete +
- *      re-set bubbles the entry to the tail).
+ *  1. **LRU semantics**: the most-recently-touched file stays in the
+ *     window; the oldest is evicted when the cap is hit. We use a
+ *     `Map` so insertion order doubles as recency order (delete +
+ *     re-set bubbles the entry to the tail).
  *
- *   2. **Source tracking**: every `track()` call records the source -
- *      `read` (agent fetched the file), `edit` (agent modified it),
- *      `write` (agent created it). The source seeds future heuristics
- *      (e.g. always pin edited files near the cap, never evict files
- *      written this session) but Phase 1 keeps the policy simple:
- *      pure LRU.
+ *  2. **Source tracking**: every `track()` call records the source -
+ *     `read` (agent fetched the file), `edit` (agent modified it),
+ *     `write` (agent created it). The source seeds future heuristics
+ *     (e.g. always pin edited files near the cap, never evict files
+ *     written this session) but Phase 1 keeps the policy simple:
+ *     pure LRU.
  *
- *   3. **No persistence**: working set is in-memory only. A REPL
- *      restart rebuilds from scratch (and from `/resume` SessionStore
- *      replay if/when we wire that). Per α6.5 spec: "node:sqlite NOT
- *      needed for this sprint."
+ *  3. **No persistence**: working set is in-memory only. A REPL
+ *     restart rebuilds from scratch (and from `/resume` SessionStore
+ *     replay if/when we wire that). Per spec: "node:sqlite NOT
+ *     needed for this sprint."
  *
- *   4. **Path normalisation**: we resolve every path to an absolute
- *      form on insert so two `track()` calls with `./foo.ts` and
- *      `/abs/cwd/foo.ts` collapse to one entry.
+ *  4. **Path normalisation**: we resolve every path to an absolute
+ *     form on insert so two `track()` calls with `./foo.ts` and
+ *     `/abs/cwd/foo.ts` collapse to one entry.
  *
- *   5. **Defensive cap**: `MAX_WORKING_SET = 50` per spec. We hold the
- *      cap as a configurable option so tests can dial it down to
- *      exercise eviction without 51 fixture files.
+ *  5. **Defensive cap**: `MAX_WORKING_SET = 50` per spec. We hold the
+ *     cap as a configurable option so tests can dial it down to
+ *     exercise eviction without 51 fixture files.
  */
 import { resolve } from 'node:path';
-/** Spec-mandated default cap. Mirrors the doc string in the α6.5 sprint plan. */
+/** Spec-mandated default cap. Mirrors the doc string in the sprint plan. */
 export const DEFAULT_WORKING_SET_CAPACITY = 50;
 export class WorkingSet {
     entries = new Map();

package/dist/core/coordinator/agent-tools.js

@@ -0,0 +1,77 @@
+function snapshot(task) {
+    return { ...task };
+}
+function isTerminal(status) {
+    return status === 'completed' || status === 'cancelled' || status === 'failed';
+}
+export function createAgentCoordinator(options) {
+    const tasks = new Map();
+    return {
+        async createTask(agentType, prompt) {
+            const { taskId } = await options.spawn(agentType, prompt);
+            const task = {
+                id: taskId,
+                agentType,
+                prompt,
+                status: 'queued',
+                createdAt: Date.now(),
+            };
+            tasks.set(task.id, task);
+            task.status = 'running';
+            task.startedAt = Date.now();
+            return snapshot(task);
+        },
+        async sendMessage(taskId, message) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                throw new Error(`agent task ${taskId} not found`);
+            }
+            if (task.status !== 'running') {
+                throw new Error(`agent task ${taskId} is not running (status=${task.status})`);
+            }
+            await options.send(taskId, message);
+        },
+        async stopTask(taskId) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                throw new Error(`agent task ${taskId} not found`);
+            }
+            if (isTerminal(task.status)) {
+                return;
+            }
+            await options.stop(taskId);
+            task.status = 'cancelled';
+            task.completedAt = Date.now();
+        },
+        listTasks() {
+            return Array.from(tasks.values())
+                .sort((a, b) => b.createdAt - a.createdAt)
+                .map(snapshot);
+        },
+        getTask(taskId) {
+            const task = tasks.get(taskId);
+            return task ? snapshot(task) : null;
+        },
+        markCompleted(taskId, output) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                return;
+            }
+            task.status = 'completed';
+            task.completedAt = Date.now();
+            task.output = output;
+            delete task.error;
+        },
+        markFailed(taskId, error) {
+            const task = tasks.get(taskId);
+            if (!task) {
+                return;
+            }
+            task.status = 'failed';
+            task.completedAt = Date.now();
+            task.error = error;
+            delete task.output;
+        },
+    };
+}
+//# sourceMappingURL=agent-tools.js.map

package/dist/core/coordinator/agent-toolset.js

@@ -0,0 +1,65 @@
+// apps/pugi-cli/src/core/coordinator/agent-toolset.ts
+import { randomUUID } from 'node:crypto';
+export class AgentCoordinator {
+    agents = new Map();
+    spawnAgent(subagentType, prompt) {
+        const handle = {
+            id: randomUUID(),
+            subagentType,
+            prompt,
+            status: 'spawned',
+            spawnedAt: new Date().toISOString(),
+        };
+        this.agents.set(handle.id, handle);
+        return handle;
+    }
+    sendMessage(agentId, _message) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return { ok: false, reason: `agent ${agentId} not found` };
+        }
+        if (agent.status !== 'spawned' && agent.status !== 'running') {
+            return { ok: false, reason: `agent ${agentId} not accepting messages (status=${agent.status})` };
+        }
+        return { ok: true };
+    }
+    taskStop(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return { ok: false, reason: `agent ${agentId} not found` };
+        }
+        agent.status = 'stopped';
+        agent.completedAt = new Date().toISOString();
+        return { ok: true };
+    }
+    markCompleted(agentId, result) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'completed';
+        agent.completedAt = new Date().toISOString();
+        agent.result = result;
+    }
+    markFailed(agentId, reason) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        agent.status = 'failed';
+        agent.completedAt = new Date().toISOString();
+        agent.result = reason;
+    }
+    listAgents(filter) {
+        const all = Array.from(this.agents.values());
+        if (!filter?.status) {
+            return all;
+        }
+        const wanted = filter.status;
+        return all.filter((a) => a.status === wanted);
+    }
+    getAgent(id) {
+        return this.agents.get(id);
+    }
+}
+//# sourceMappingURL=agent-toolset.js.map

package/dist/core/coordinator/fsm.js

@@ -0,0 +1,73 @@
+export class CoordinatorFSM {
+    state;
+    constructor() {
+        this.state = {
+            phase: 'research',
+            inflightOps: [],
+            completedPhases: [],
+        };
+    }
+    getState() {
+        // Return a shallow copy to prevent direct mutation of the internal state.
+        return {
+            ...this.state,
+            inflightOps: [...this.state.inflightOps],
+            completedPhases: [...this.state.completedPhases],
+        };
+    }
+    canStart(op) {
+        switch (this.state.phase) {
+            case 'research':
+                return op === 'read';
+            case 'synth':
+                return op === 'read';
+            case 'impl':
+                if (op === 'write') {
+                    // 'write' is only allowed when no other operations are in flight.
+                    return this.state.inflightOps.length === 0;
+                }
+                // 'read' and 'exec' are allowed as long as no 'write' is in flight.
+                return !this.state.inflightOps.includes('write');
+            case 'done':
+                return false;
+            default:
+                return false;
+        }
+    }
+    start(op) {
+        if (!this.canStart(op)) {
+            throw new Error(`Operation '${op}' cannot be started in phase '${this.state.phase}' with inflight ops: [${this.state.inflightOps.join(', ')}]`);
+        }
+        this.state.inflightOps.push(op);
+    }
+    finish(op) {
+        const opIndex = this.state.inflightOps.indexOf(op);
+        if (opIndex === -1) {
+            throw new Error(`Cannot finish operation '${op}' as it is not in flight. Inflight ops: [${this.state.inflightOps.join(', ')}]`);
+        }
+        this.state.inflightOps.splice(opIndex, 1);
+    }
+    advance() {
+        if (this.state.inflightOps.length > 0) {
+            throw new Error(`Cannot advance phase with operations in flight: [${this.state.inflightOps.join(', ')}]`);
+        }
+        const currentPhase = this.state.phase;
+        let nextPhase;
+        switch (currentPhase) {
+            case 'research':
+                nextPhase = 'synth';
+                break;
+            case 'synth':
+                nextPhase = 'impl';
+                break;
+            case 'impl':
+                nextPhase = 'done';
+                break;
+            case 'done':
+                throw new Error("Cannot advance from final phase 'done'.");
+        }
+        this.state.completedPhases.push(currentPhase);
+        this.state.phase = nextPhase;
+    }
+}
+//# sourceMappingURL=fsm.js.map

package/dist/core/coordinator/mode-fsm.js

@@ -0,0 +1,70 @@
+const isQuiescent = (state) => state.readTasks === 0 && !state.writeTaskActive;
+export const MODE_TRANSITIONS = [
+    { from: 'idle', to: 'research', trigger: 'plan', guard: isQuiescent },
+    { from: 'research', to: 'synth', trigger: 'synthesize', guard: isQuiescent },
+    { from: 'synth', to: 'impl', trigger: 'execute', guard: isQuiescent },
+    { from: 'impl', to: 'review', trigger: 'verify', guard: isQuiescent },
+    { from: 'review', to: 'done', trigger: 'accept', guard: isQuiescent },
+    { from: 'review', to: 'impl', trigger: 'fix', guard: isQuiescent },
+    { from: 'idle', to: 'idle', trigger: 'reset' },
+    { from: 'research', to: 'idle', trigger: 'reset' },
+    { from: 'synth', to: 'idle', trigger: 'reset' },
+    { from: 'impl', to: 'idle', trigger: 'reset' },
+    { from: 'review', to: 'idle', trigger: 'reset' },
+    { from: 'done', to: 'idle', trigger: 'reset' },
+];
+class CoordinatorModeFSM {
+    state;
+    constructor(initial = 'idle') {
+        this.state = {
+            mode: initial,
+            enteredAt: Date.now(),
+            readTasks: 0,
+            writeTaskActive: false,
+        };
+    }
+    current() {
+        return { ...this.state };
+    }
+    trigger(event) {
+        const transition = MODE_TRANSITIONS.find((candidate) => candidate.from === this.state.mode && candidate.trigger === event);
+        if (!transition) {
+            return {
+                ok: false,
+                reason: `No transition for event '${event}' from mode '${this.state.mode}'.`,
+            };
+        }
+        if (transition.guard && !transition.guard(this.current())) {
+            return {
+                ok: false,
+                reason: `Guard blocked event '${event}' from mode '${this.state.mode}'.`,
+            };
+        }
+        this.state = {
+            ...this.state,
+            mode: transition.to,
+            enteredAt: Date.now(),
+        };
+        return { ok: true };
+    }
+    beginRead() {
+        this.state.readTasks += 1;
+    }
+    endRead() {
+        this.state.readTasks = Math.max(0, this.state.readTasks - 1);
+    }
+    beginWrite() {
+        if (this.state.writeTaskActive) {
+            return { ok: false, reason: 'A write task is already active.' };
+        }
+        this.state.writeTaskActive = true;
+        return { ok: true };
+    }
+    endWrite() {
+        this.state.writeTaskActive = false;
+    }
+}
+export function createFSM(initial) {
+    return new CoordinatorModeFSM(initial);
+}
+//# sourceMappingURL=mode-fsm.js.map

package/dist/core/cost/rate-card.js

@@ -0,0 +1,129 @@
+/**
+ * Rate card for the `pugi cost` / `/cost` / `/usage` surface — L19 sprint.
+ *
+ * Distinct from `core/repl/model-pricing.ts` on purpose:
+ *
+ *  - `model-pricing.ts` powers the TUI cost meter (per-turn flash, status
+ *    row USD). Its ladder is keyed against the live Anvil model slugs and
+ *    intentionally inflates an honest worst-case figure via the Sonnet
+ *    fallback so an operator on a quiet model never gets billed by a
+ *    surprise. It rounds to USD per 1M tokens at runtime.
+ *
+ *  - `rate-card.ts` (this file) powers the persisted `/cost` table the
+ *    operator reads to plan budget. It distinguishes open-weight models
+ *    ($0 / $0 — infra cost only) from hosted closed models so the table
+ *    does not double-charge an operator running a self-hosted Qwen or
+ *    Kimi behind Pugi. The L19 spec calls these out by name.
+ *
+ * Both ladders intentionally agree on Anthropic Claude family pricing so
+ * the TUI flash and the persisted table cannot disagree on a Claude turn.
+ * If they diverge, the per-model-pricing ladder wins for live UI; the
+ * rate card here wins for the persisted `.pugi/cost.json` aggregate.
+ *
+ * Prices are USD per 1,000,000 tokens, sourced from the L19 spec
+ * which mirrors provider list-price pages as of that date.
+ */
+/**
+ * Exact-match price ladder keyed by model slug. Slugs match the L19 task
+ * spec verbatim so a copy-paste from the sprint doc resolves without
+ * normalisation.
+ */
+export const RATES_PER_MTOKEN = Object.freeze({
+    // Anthropic Claude family (hosted, billed).
+    'claude-opus-4-7': { input: 15, output: 75 },
+    'claude-opus-4-6': { input: 15, output: 75 },
+    'claude-sonnet-4-6': { input: 3, output: 15 },
+    'claude-sonnet-4-5': { input: 3, output: 15 },
+    'claude-haiku-4-5-20251001': { input: 1, output: 5 },
+    'claude-haiku-4-5': { input: 1, output: 5 },
+    // Open-weight models — infra cost only, never per-token billed. The
+    // note column surfaces the reason so a CFO reading the JSON envelope
+    // does not assume the row is broken.
+    'qwen3-coder-480b-instruct-fp8': { input: 0, output: 0, note: 'open-weight' },
+    'kimi-k2.6': { input: 0, output: 0, note: 'open-weight' },
+    'deepseek-v4-pro': { input: 0, output: 0, note: 'open-weight' },
+});
+/**
+ * Family-prefix fallback — used only when an exact slug miss. Mirrors the
+ * approach in `model-pricing.ts` so a future model rebind (e.g.
+ * `claude-opus-4-8`) prices reasonably without a code edit.
+ */
+const FAMILY_FALLBACKS = [
+    ['claude-opus-', { input: 15, output: 75 }],
+    ['claude-sonnet-', { input: 3, output: 15 }],
+    ['claude-haiku-', { input: 1, output: 5 }],
+    ['qwen', { input: 0, output: 0, note: 'open-weight' }],
+    ['kimi', { input: 0, output: 0, note: 'open-weight' }],
+    ['deepseek', { input: 0, output: 0, note: 'open-weight' }],
+];
+/**
+ * Final fallback for unknown slugs. Pinned to Sonnet-tier — same posture
+ * as `model-pricing.ts`'s default, so an unrecognised hosted model bills
+ * "honestly conservative" rather than $0 (which would silently hide cost
+ * from the operator).
+ */
+const DEFAULT_RATE = { input: 3, output: 15, note: 'unknown model — Sonnet-tier estimate' };
+/**
+ * Look up the rate for a model slug.
+ *
+ * Resolution order:
+ *  1. Exact match in `RATES_PER_MTOKEN`.
+ *  2. Family-prefix match (first hit wins).
+ *  3. Default Sonnet-tier estimate.
+ *
+ * Pure, never throws. Called on every cost-tracker write so the hot path
+ * stays branch-cheap.
+ */
+export function rateFor(model) {
+    if (!model || typeof model !== 'string')
+        return DEFAULT_RATE;
+    const exact = RATES_PER_MTOKEN[model];
+    if (exact)
+        return exact;
+    for (const [prefix, rate] of FAMILY_FALLBACKS) {
+        if (model.startsWith(prefix))
+            return rate;
+    }
+    return DEFAULT_RATE;
+}
+/**
+ * Compute the USD cost for a single (model, inputTokens, outputTokens)
+ * triple. Defensive against negative / NaN inputs — out-of-range values
+ * floor to zero so a buggy upstream cannot credit a negative cost.
+ */
+export function estimateUsd(model, inputTokens, outputTokens) {
+    const rate = rateFor(model);
+    const safeIn = Number.isFinite(inputTokens) && inputTokens > 0 ? inputTokens : 0;
+    const safeOut = Number.isFinite(outputTokens) && outputTokens > 0 ? outputTokens : 0;
+    const usd = (safeIn * rate.input + safeOut * rate.output) / 1_000_000;
+    return Number.isFinite(usd) && usd > 0 ? usd : 0;
+}
+/**
+ * Format a USD figure for the `/cost` table.
+ *
+ *  - `≥ $0.01` → two decimals (`$0.46`).
+ *  - `< $0.01` but `> 0` → three decimals (`$0.003`) so fractions of a
+ *    cent are honest instead of rounding to `$0.00`.
+ *  - Exactly `0` or NaN → `$0.00`.
+ *
+ * Mirrors `formatCostUsd` from `model-pricing.ts` intentionally — both
+ * surfaces should print the same number in the same shape.
+ */
+export function formatUsd(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '$0.00';
+    if (value >= 0.01)
+        return `$${value.toFixed(2)}`;
+    return `$${value.toFixed(3)}`;
+}
+/**
+ * Format a token count for the `/cost` table. Uses comma-thousands so the
+ * table reads `14,300` instead of `14.3k` — distinct from the TUI status
+ * row which uses `k`/`m` shortening to save column width.
+ */
+export function formatTokensWithCommas(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '0';
+    return Math.floor(value).toLocaleString('en-US');
+}
+//# sourceMappingURL=rate-card.js.map