@fyeeme/pi-statusline 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2025-05-31
+
+### Added
+
+- Initial release
+- Two-line footer: cwd + git branch (left) / model + thinking level (right), and token stats line
+- Token usage: input, output, cache read/write, total per session
+- Cost display with auto currency detection (¥ for DeepSeek, $ otherwise)
+- DeepSeek account balance fetched on startup, cached 5 minutes
+- Context window usage percentage and size
+- Elapsed time and tokens/sec for last response
+- MCP server connection count and tool count via `mcp:status` / `mcp:disconnect` events
+- `/balance` command to force-refresh DeepSeek balance
+- `/currency [auto|¥|$]` command to toggle cost currency
+- `/status-debug` command to dump session stats to log file

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# pi-statusline
+
+A rich custom status bar for [pi](https://pi.dev) that replaces the default footer.
+
+## Features
+
+- **Token usage**: input, output, cache read/write, total per session
+- **Cost**: cumulative cost with currency auto-detection (¥ for DeepSeek, $ otherwise)
+- **DeepSeek balance**: live account balance fetched on startup and cached for 5 minutes
+- **Context window**: usage percentage and size
+- **Timing**: elapsed time + tokens/sec for last response
+- **MCP status**: connected server count and total tool count
+- **Git branch**: current branch shown in cwd display
+
+## Install
+
+Requires the [pi](https://pi.dev) CLI.
+
+### From npm (recommended)
+
+```bash
+# Global (user) install — available in every project
+pi install npm:@fyeeme/pi-statusline
+
+# Project-local — written to .pi/settings.json, shareable with your team
+pi install -l npm:@fyeeme/pi-statusline
+
+# Pinned version — skipped by `pi update`
+pi install npm:@fyeeme/pi-statusline@1.0.0
+
+# Try it once without saving (current run only)
+pi -e npm:@fyeeme/pi-statusline
+```
+
+### From GitHub
+
+Source: [`fyeeme/pi-packages`](https://github.com/fyeeme/pi-packages).
+
+```bash
+# HTTPS shorthand
+pi install git:github.com/fyeeme/pi-packages
+# Pin to a tag or commit (skipped by `pi update`)
+pi install git:github.com/fyeeme/pi-packages@v1.0.0
+# Raw URL form
+pi install https://github.com/fyeeme/pi-packages
+```
+
+See the Pi Packages guide on [pi.dev](https://pi.dev) for the full list of source types, scopes, and `pi update` behavior.
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `/balance` | Force refresh DeepSeek account balance |
+| `/currency [auto\|¥\|$]` | Toggle cost currency display |
+| `/status-debug` | Dump session stats to `/tmp/pi-status-debug.log` |
+
+## Status Bar Layout
+
+```
+~/projects/my-repo (main)                    deepseek-v3 · xhigh
+in 12k, out 8k, cache 45k, total 65k · ¥0.12/50.00 · 12.3%/64k · 45s 38.2 tok/s · MCP:2(15)
+```
+
+Line 1: cwd + git branch (left) | model + thinking level (right)
+Line 2: token stats · cost/balance · context · timing · MCP
+
+## MCP Integration
+
+When used with [pi-mcp-adapter](https://www.npmjs.com/package/pi-mcp-adapter), the status bar shows live MCP connection status via `mcp:status` and `mcp:disconnect` events.

package/cache.ts

@@ -0,0 +1,63 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ProviderUsageResult } from "./types.ts";
+import type { UsageProvider } from "./providers/types.ts";
+
+export type ProviderRegistry = Record<string, UsageProvider>;
+
+interface CacheEntry {
+	result: ProviderUsageResult;
+	fetchedAt: number;
+}
+
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+let usageCache: CacheEntry | null = null;
+
+export function resetUsageCache(): void {
+	usageCache = null;
+}
+
+export function getUsageCache(): CacheEntry | null {
+	return usageCache;
+}
+
+export async function refreshUsage(
+	providers: ProviderRegistry,
+	modelRegistry: ExtensionContext["modelRegistry"],
+	model: ExtensionContext["model"],
+): Promise<ProviderUsageResult> {
+	const providerName = model?.provider ?? "";
+	const provider = providers[providerName];
+	if (!provider) {
+		usageCache = null;
+		return null;
+	}
+
+	const result = await provider.fetchUsage(modelRegistry, model);
+	if (result) {
+		usageCache = { result, fetchedAt: Date.now() };
+	} else {
+		usageCache = null;
+	}
+	return result;
+}
+
+export function getUsageCacheAge(): number | null {
+	if (!usageCache) return null;
+	return Date.now() - usageCache.fetchedAt;
+}
+
+export function getCachedUsage(
+	providers: ProviderRegistry,
+	lastCtx: ExtensionContext | null,
+	lastModel: ExtensionContext["model"] | undefined,
+): ProviderUsageResult {
+	if (!usageCache) return null;
+	if (Date.now() - usageCache.fetchedAt > CACHE_TTL_MS) {
+		// TTL expired: return stale data but trigger background refresh
+		if (lastCtx && lastModel) {
+			void refreshUsage(providers, lastCtx.modelRegistry, lastModel);
+		}
+	}
+	return usageCache.result;
+}

package/footer.ts

@@ -0,0 +1,152 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { ContextUsage } from "@earendil-works/pi-coding-agent";
+import type { ProviderUsageResult } from "./types.ts";
+import type { TokenUsage } from "./types.ts";
+import type { UsageProvider } from "./providers/types.ts";
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+export function fmt(n: number): string {
+	if (n < 1000) return n.toString();
+	if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+	if (n < 1000000) return `${Math.round(n / 1000)}k`;
+	if (n < 10000000) return `${(n / 1000000).toFixed(1)}M`;
+	return `${Math.round(n / 1000000)}M`;
+}
+
+export function formatDuration(sec: number): string {
+	if (sec < 60) return `${Math.floor(sec)}s`;
+	const min = Math.floor(sec / 60);
+	const s = Math.floor(sec % 60);
+	return `${min}m${s}s`;
+}
+
+/** Format countdown from epoch ms to XhYm string. */
+export function formatCountdown(resetAt: number): string {
+	if (!resetAt) return "?";
+	const remainingMs = resetAt - Date.now();
+	if (remainingMs <= 0) return "0m";
+	const totalMin = Math.floor(remainingMs / 60000);
+	const h = Math.floor(totalMin / 60);
+	const m = totalMin % 60;
+	if (h > 0) return `${h}h${m}m`;
+	return `${m}m`;
+}
+
+/** Format countdown with day precision for weekly cycles. */
+export function formatWeeklyCountdown(resetAt: number): string {
+	if (!resetAt) return "?";
+	const remainingMs = resetAt - Date.now();
+	if (remainingMs <= 0) return "0h";
+	const totalMin = Math.floor(remainingMs / 60000);
+	const d = Math.floor(totalMin / 1440);
+	const h = Math.floor((totalMin % 1440) / 60);
+	if (d > 0) return `${d}d${h}h`;
+	const m = totalMin % 60;
+	if (h > 0) return `${h}h${m}m`;
+	return `${m}m`;
+}
+
+export function formatCwd(cwd: string): string {
+	const home = process.env.HOME || process.env.USERPROFILE;
+	if (!home) return cwd;
+	const resolvedCwd = resolve(cwd);
+	const resolvedHome = resolve(home);
+	const rel = relative(resolvedHome, resolvedCwd);
+	const insideHome =
+		rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+	if (!insideHome) return cwd;
+	return rel === "" ? "~" : `~${sep}${rel}`;
+}
+
+export { truncateToWidth, visibleWidth };
+
+// ---------------------------------------------------------------------------
+// Footer line builders
+// ---------------------------------------------------------------------------
+
+export function buildStatLine(
+	stats: TokenUsage & { cost: number; currency: "¥" | "$" },
+	contextUsage: ContextUsage | undefined,
+	providerResult: ProviderUsageResult,
+	providers: Record<string, UsageProvider>,
+	getElapsedSec: () => number,
+	lastTps: number,
+	mcpStatuses: Map<string, { connected: boolean; toolCount: number }>,
+): string {
+	const mods: string[] = [];
+
+	// tokens 566k(in 29k, out 22k, cache 515k,45.2%)
+	{
+		const tok: string[] = [];
+		if (stats.input) tok.push(`in ${fmt(stats.input)}`);
+		if (stats.output) tok.push(`out ${fmt(stats.output)}`);
+		const cache = stats.cacheRead + stats.cacheWrite;
+		if (cache) {
+			const cacheStr = stats.hitRate > 0
+				? `cache ${fmt(cache)},${(stats.hitRate * 100).toFixed(1)}%`
+				: `cache ${fmt(cache)}`;
+			tok.push(cacheStr);
+		}
+		if (tok.length > 0 && stats.total) {
+			mods.push(`tokens ${fmt(stats.total)}(${tok.join(", ")})`);
+		} else if (tok.length > 0) {
+			mods.push(tok.join(", "));
+		}
+	}
+
+	// Provider-specific cost/usage
+	if (providerResult) {
+		const providerName = providerResult.provider;
+		const provider = providers[providerName];
+		if (provider) {
+			const formatted = provider.formatForFooter(providerResult, stats.cost, stats.currency);
+			if (formatted) mods.push(formatted);
+		}
+	} else {
+		if (stats.cost > 0) {
+			mods.push(`${stats.currency}${stats.cost.toFixed(2)}`);
+		}
+	}
+
+	// context: 45.2%/16k or ?/16k
+	if (contextUsage) {
+		const w = fmt(contextUsage.contextWindow);
+		mods.push(
+			contextUsage.percent !== null
+				? `${contextUsage.percent.toFixed(1)}%/${w}`
+				: `?/${w}`,
+		);
+	}
+
+	// timing: 2m30s 39.5 tok/s
+	{
+		const t: string[] = [];
+		const elapsed = getElapsedSec();
+		if (elapsed > 0) t.push(formatDuration(elapsed));
+		if (lastTps > 0) t.push(`${lastTps.toFixed(1)} tok/s`);
+		if (t.length) mods.push(t.join(" "));
+	}
+
+	// MCP: MCP:2(15) or MCP:0
+	{
+		const entries = Array.from(mcpStatuses.entries());
+		if (entries.length) {
+			const connected = entries.filter(([, s]) => s.connected).length;
+			const tools = entries.reduce((sum, [, s]) => sum + s.toolCount, 0);
+			mods.push(connected > 0 ? `MCP:${connected}(${tools})` : "MCP:0");
+		}
+	}
+
+	return mods.join(" · ");
+}
+
+export function buildInfoLine(modelId: string | undefined, thinkingLevel: string): string {
+	const parts: string[] = [];
+	if (modelId) parts.push(modelId);
+	if (thinkingLevel && thinkingLevel !== "off") parts.push(thinkingLevel);
+	return parts.join(" · ");
+}

package/index.ts

@@ -0,0 +1,258 @@
+/**
+ * Status Line Extension v3
+ *
+ * Replaces the default footer with a custom status line.
+ * Uses a strategy pattern to show provider-aware usage data:
+ *   - DeepSeek: balance + weekly tokens (from session files)
+ *   - ZAI/GLM:  rolling quota (5h + MCP) + weekly tokens (from API)
+ *   - Others:   session-scoped cost only
+ *
+ * Commands:
+ *   /status-debug  - dump session stats to /tmp/pi-status-debug.log
+ *   /currency      - toggle ¥ / $ / auto
+ */
+
+import { appendFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+import { DeepSeekUsageProvider } from "./providers/deepseek.ts";
+import { ZaiUsageProvider } from "./providers/zai.ts";
+import type { UsageProvider } from "./providers/types.ts";
+import { SessionTokenUsageCalculator } from "./token-usage.ts";
+import { refreshUsage, getCachedUsage, getUsageCacheAge } from "./cache.ts";
+import { formatCwd, buildStatLine, buildInfoLine } from "./footer.ts";
+
+// ---------------------------------------------------------------------------
+// Provider registry
+// ---------------------------------------------------------------------------
+
+const providers: Record<string, UsageProvider> = {
+	deepseek: new DeepSeekUsageProvider(),
+	zai: new ZaiUsageProvider(),
+	"zai-coding-cn": new ZaiUsageProvider(),
+};
+
+// ---------------------------------------------------------------------------
+// Runtime state
+// ---------------------------------------------------------------------------
+
+let agentStartMs: number | null = null;
+let lastCtx: ExtensionContext | null = null;
+let lastModel: ExtensionContext["model"] = undefined;
+let agentRunning = false;
+let lastElapsedSec = 0;
+let lastTps = 0;
+let currencyOverride: "¥" | "$" | undefined = undefined;
+
+const mcpStatuses = new Map<string, { connected: boolean; toolCount: number }>();
+
+const tokenCalculator = new SessionTokenUsageCalculator(() => currencyOverride);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getElapsedSec(): number {
+	if (agentRunning && agentStartMs !== null) return (Date.now() - agentStartMs) / 1000;
+	return lastElapsedSec;
+}
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+export default function (pi: ExtensionAPI) {
+	pi.on("agent_start", () => {
+		agentStartMs = Date.now();
+		agentRunning = true;
+	});
+
+	pi.on("agent_end", (event) => {
+		agentRunning = false;
+		if (agentStartMs === null) return;
+		const elapsedMs = Date.now() - agentStartMs;
+		if (elapsedMs <= 0) return;
+		lastElapsedSec += elapsedMs / 1000;
+
+		// Compute cumulative output tokens from all assistant messages in the session
+		let cumulativeOutput = 0;
+		if (lastCtx) {
+			for (const entry of lastCtx.sessionManager.getEntries()) {
+				if (entry.type === "message" && entry.message.role === "assistant") {
+					cumulativeOutput += (entry.message as AssistantMessage).usage.output;
+				}
+			}
+		} else {
+			// fallback: use current turn's messages when no session context
+			for (const m of event.messages) {
+				if (m.role === "assistant") cumulativeOutput += (m as AssistantMessage).usage.output;
+			}
+		}
+		lastTps = cumulativeOutput > 0 ? cumulativeOutput / lastElapsedSec : 0;
+
+		// Schedule background refresh to pick up new usage data
+		if (lastCtx && lastModel) {
+			void refreshUsage(providers, lastCtx.modelRegistry, lastModel);
+		}
+	});
+
+	pi.events.on("mcp:status", (raw) => {
+		const data = raw as { id: string; connected: boolean; toolCount: number };
+		mcpStatuses.set(data.id, { connected: data.connected, toolCount: data.toolCount });
+	});
+	pi.events.on("mcp:disconnect", (raw) => {
+		mcpStatuses.delete((raw as { id: string }).id);
+	});
+
+	// ---- /status-debug ----
+	pi.registerCommand("status-debug", {
+		description: "Dump session stats to /tmp/pi-status-debug.log + console.error",
+		handler: async (_args, ctx) => {
+			const logPath = `${tmpdir()}/pi-status-debug.log`;
+			const w = (s: string) => {
+				console.error(s);
+				try { appendFileSync(logPath, s + "\n"); } catch { /* ok */ }
+			};
+
+			w("=== STATUS-LINE DEBUG ===");
+			w(`cwd: ${ctx.cwd}`);
+			w(`model: ${ctx.model?.provider}/${ctx.model?.id}`);
+			w(`thinking: ${pi.getThinkingLevel()}`);
+
+			const cu = ctx.getContextUsage();
+			w(`contextUsage: tokens=${cu?.tokens ?? "?"} window=${cu?.contextWindow ?? "?"} percent=${cu?.percent ?? "?"}`);
+
+			// Usage cache dump
+			w(`--- provider usage ---`);
+			const cached = getCachedUsage(providers, lastCtx, lastModel);
+			if (cached) {
+				w(`  provider: ${cached.provider}`);
+				const dbgProvider = providers[cached.provider];
+				if (dbgProvider) dbgProvider.debugDump(cached, w);
+			} else {
+				w(`  (no cached usage data)`);
+			}
+			const cacheAge = getUsageCacheAge();
+			w(`  cacheAge: ${cacheAge !== null ? `${Math.round(cacheAge / 1000)}s` : "N/A"}`);
+
+			let idx = 0;
+			for (const entry of ctx.sessionManager.getEntries()) {
+				if (entry.type === "message" && entry.message.role === "assistant") {
+					const m = entry.message as AssistantMessage;
+					w(`--- msg[${idx}] ---`);
+					w(`  usage: ${JSON.stringify(m.usage)}`);
+					w(`  model: ${m.model}`);
+					w(`  cost: ${JSON.stringify(m.usage.cost)}`);
+					idx++;
+				}
+			}
+
+			const stats = tokenCalculator.compute(ctx);
+			w(`--- computed ---`);
+			w(`  input=${stats.input} output=${stats.output}`);
+			w(`  cacheRead=${stats.cacheRead} cacheWrite=${stats.cacheWrite}`);
+			w(`  total=${stats.total} cost=${stats.cost} currency=${stats.currency}`);
+			w(`  hitRate=${(stats.hitRate * 100).toFixed(1)}%`);
+			w("=========================");
+
+			ctx.ui.notify(`Debug written to ${logPath} (${idx} msgs)`, "info");
+		},
+	});
+
+	// ---- /currency ----
+	pi.registerCommand("currency", {
+		description: "Toggle cost currency (auto / ¥ / $)",
+		handler: async (args, ctx) => {
+			const a = args.trim().toLowerCase();
+			if (a === "auto" || a === "") {
+				currencyOverride = undefined;
+				ctx.ui.notify("Currency: auto (deepseek→¥)", "info");
+			} else if (a === "¥" || a === "rmb" || a === "cny") {
+				currencyOverride = "¥";
+				ctx.ui.notify("Currency: ¥", "info");
+			} else if (a === "$" || a === "usd") {
+				currencyOverride = "$";
+				ctx.ui.notify("Currency: $", "info");
+			} else {
+				ctx.ui.notify("Usage: /currency [auto|¥|$]", "warning");
+			}
+		},
+	});
+
+	// ---- Model switch: refresh usage when provider changes ----
+	pi.on("model_select", (event) => {
+		if (lastCtx) {
+			lastModel = event.model;
+			void refreshUsage(providers, lastCtx.modelRegistry, event.model);
+		}
+	});
+
+	// ---- Footer ----
+	pi.on("session_start", (_event, ctx) => {
+		if (!ctx.hasUI) return;
+
+		// Reset cumulative timing for new session
+		lastElapsedSec = 0;
+		lastTps = 0;
+
+		// Prime usage cache on startup (non-blocking)
+		lastCtx = ctx;
+		lastModel = ctx.model;
+		void refreshUsage(providers, ctx.modelRegistry, ctx.model);
+
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			const unsub = footerData.onBranchChange(() => tui.requestRender());
+
+			return {
+				dispose: unsub,
+				invalidate() {},
+				render(width: number): string[] {
+					const stats = tokenCalculator.compute(ctx);
+					const cu = ctx.getContextUsage();
+					const model = ctx.model;
+					const level = pi.getThinkingLevel();
+					const providerResult = getCachedUsage(providers, lastCtx, lastModel);
+					const dim = (s: string) => theme.fg("dim", s);
+					const lines: string[] = [];
+
+					// Line 0: cwd + git branch (left)  |  model · thinking (right)
+					let pwd = formatCwd(ctx.cwd);
+					const branch = footerData.getGitBranch();
+					if (branch) pwd = `${pwd} (${branch})`;
+					const left = dim(pwd);
+					const right = dim(buildInfoLine(model?.id, level));
+					const leftW = visibleWidth(left);
+					const rightW = visibleWidth(right);
+					if (leftW + rightW + 2 <= width) {
+						const pad = " ".repeat(width - leftW - rightW);
+						lines.push(left + pad + right);
+					} else {
+						lines.push(truncateToWidth(left + "  " + right, width, dim("...")));
+					}
+
+					// Line 1: tokens + cost + provider usage + context + elapsed + tps + mcp
+					lines.push(truncateToWidth(
+						dim(buildStatLine(stats, cu, providerResult, providers, getElapsedSec, lastTps, mcpStatuses)),
+						width,
+						dim("..."),
+					));
+
+					// Line 2: extension statuses
+					const extStatuses = footerData.getExtensionStatuses();
+					if (extStatuses.size > 0) {
+						const text = Array.from(extStatuses.entries())
+							.sort(([a], [b]) => a.localeCompare(b))
+							.map(([, t]) => t.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim())
+							.join(" ");
+						lines.push(truncateToWidth(text, width, dim("...")));
+					}
+
+					return lines;
+				},
+			};
+		});
+	});
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@fyeeme/pi-statusline",
+  "version": "1.0.0",
+  "description": "Rich custom status bar for pi with token usage, cost, DeepSeek balance, context window, timing, and MCP connection status.",
+  "type": "module",
+  "license": "MIT",
+  "author": "fyeeme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fyeeme/pi-packages"
+  },
+  "bugs": {
+    "url": "https://github.com/fyeeme/pi-packages/issues"
+  },
+  "homepage": "https://github.com/fyeeme/pi-packages#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "status-line",
+    "statusline",
+    "deepseek",
+    "tokens",
+    "cost",
+    "mcp",
+    "balance",
+    "footer"
+  ],
+  "files": [
+    "*.ts",
+    "providers/*.ts",
+    "quota/*.ts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "scripts": {
+    "test": "vitest --run",
+    "typecheck": "tsc"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.77.0",
+    "@earendil-works/pi-ai": ">=0.77.0",
+    "@earendil-works/pi-tui": ">=0.77.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.77.0",
+    "@earendil-works/pi-ai": "0.77.0",
+    "@earendil-works/pi-tui": "0.77.0",
+    "@types/node": "22.19.19",
+    "typescript": "5.9.3"
+  }
+}

package/providers/deepseek.ts

@@ -0,0 +1,81 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { DeepSeekResult, ProviderUsageResult } from "../types.ts";
+import type { UsageProvider } from "./types.ts";
+import type { QuotaCalculator } from "../quota/types.ts";
+import { DeepSeekQuotaCalculator } from "../quota/deepseek.ts";
+import { scanWeeklyTokens } from "../session-scanner.ts";
+import { fmt } from "../footer.ts";
+
+export class DeepSeekUsageProvider implements UsageProvider {
+	quotaCalculator: QuotaCalculator = new DeepSeekQuotaCalculator();
+
+	async fetchUsage(
+		modelRegistry: ExtensionContext["modelRegistry"],
+		model: ExtensionContext["model"],
+	): Promise<ProviderUsageResult> {
+		if (!model || model.provider !== "deepseek") return null;
+
+		const apiKey = await modelRegistry.getApiKeyForProvider("deepseek");
+		if (!apiKey) return null;
+
+		let origin = "https://api.deepseek.com";
+		try {
+			const u = new URL(model.baseUrl ?? "https://api.deepseek.com");
+			origin = u.origin;
+		} catch { /* use default */ }
+
+		try {
+			const res = await fetch(`${origin}/user/balance`, {
+				headers: { Authorization: `Bearer ${apiKey}` },
+				signal: AbortSignal.timeout(5000),
+			});
+			if (!res.ok) return null;
+
+			const data = (await res.json()) as {
+				is_available?: boolean;
+				balance_infos?: Array<{
+					currency?: string;
+					total_balance?: string;
+				}>;
+			};
+
+			const info = data.balance_infos?.[0];
+			if (!info) return null;
+
+			const weeklyTokens = scanWeeklyTokens("deepseek");
+
+			return {
+				provider: "deepseek",
+				totalBalance: info.total_balance ?? "?",
+				currency: info.currency ?? "CNY",
+				weeklyTokens,
+			};
+		} catch {
+			return null;
+		}
+	}
+
+	formatForFooter(result: NonNullable<ProviderUsageResult>, sessionCost: number, currency: string): string {
+		if (result.provider !== "deepseek") return "";
+		const ds = result as DeepSeekResult;
+		const balance = `${ds.currency === "CNY" ? "¥" : "$"}${ds.totalBalance}`;
+		const weekly = ds.weeklyTokens > 0 ? `7d:${fmt(ds.weeklyTokens)}` : "";
+		const parts: string[] = [];
+
+		if (sessionCost > 0) {
+			parts.push(`${currency}${sessionCost.toFixed(2)}/${balance}`);
+		} else {
+			parts.push(balance);
+		}
+		if (weekly) parts.push(weekly);
+
+		return parts.join(" · ");
+	}
+
+	debugDump(result: NonNullable<ProviderUsageResult>, w: (s: string) => void): void {
+		if (result.provider !== "deepseek") return;
+		const ds = result as DeepSeekResult;
+		w(`  balance: ${ds.currency} ${ds.totalBalance}`);
+		w(`  weeklyTokens: ${ds.weeklyTokens}`);
+	}
+}

package/providers/types.ts

@@ -0,0 +1,13 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ProviderUsageResult } from "../types.ts";
+import type { QuotaCalculator } from "../quota/types.ts";
+
+export interface UsageProvider {
+	fetchUsage(
+		modelRegistry: ExtensionContext["modelRegistry"],
+		model: ExtensionContext["model"],
+	): Promise<ProviderUsageResult>;
+	formatForFooter(result: NonNullable<ProviderUsageResult>, sessionCost: number, currency: string): string;
+	debugDump(result: NonNullable<ProviderUsageResult>, w: (s: string) => void): void;
+	quotaCalculator: QuotaCalculator;
+}

package/providers/zai.ts

@@ -0,0 +1,178 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ZaiResult, ProviderUsageResult } from "../types.ts";
+import type { UsageProvider } from "./types.ts";
+import type { QuotaCalculator } from "../quota/types.ts";
+import { ZaiQuotaCalculator } from "../quota/zai.ts";
+import { fmt, formatCountdown, formatWeeklyCountdown } from "../footer.ts";
+import { scanWeeklyTokens } from "../session-scanner.ts";
+
+/** Check if the provider name is a ZAI/GLM variant. */
+function isZaiProvider(provider: string): boolean {
+	return provider === "zai" || provider === "zai-coding-cn";
+}
+
+export class ZaiUsageProvider implements UsageProvider {
+	quotaCalculator: QuotaCalculator = new ZaiQuotaCalculator();
+
+	async fetchUsage(
+		modelRegistry: ExtensionContext["modelRegistry"],
+		model: ExtensionContext["model"],
+	): Promise<ProviderUsageResult> {
+		if (!model || !isZaiProvider(model.provider)) return null;
+
+		const apiKey = await modelRegistry.getApiKeyForProvider(model.provider);
+		if (!apiKey) return null;
+
+		const defaultOrigin = model.provider === "zai-coding-cn"
+			? "https://open.bigmodel.cn"
+			: "https://api.z.ai";
+		let origin = defaultOrigin;
+		try {
+			origin = new URL(model.baseUrl ?? defaultOrigin).origin;
+		} catch { /* use default */ }
+
+		const headers: Record<string, string> = {
+			Authorization: apiKey,
+			"Accept-Language": "en-US,en",
+			"Content-Type": "application/json",
+		};
+
+		try {
+			// Fetch quota limits
+			const quotaRes = await fetch(`${origin}/api/monitor/usage/quota/limit`, {
+				headers,
+				signal: AbortSignal.timeout(5000),
+			});
+			if (!quotaRes.ok) return null;
+
+			const quotaData = (await quotaRes.json()) as {
+				data?: {
+					limits?: Array<{
+						type: string;
+						unit?: number;
+						percentage?: number;
+						nextResetTime?: number;
+					}>;
+					level?: string;
+				};
+			};
+
+			const limits = quotaData.data?.limits ?? [];
+			const fiveHourLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 3);
+			const weeklyLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 6);
+			const level = quotaData.data?.level ?? "";
+
+			const now = Date.now();
+			let weeklyTokens = 0;
+			let weeklyResetAt = 0;
+			let weeklyPct = 0;
+			let isNaturalWeek = false;
+
+			if (weeklyLimit && weeklyLimit.nextResetTime && weeklyLimit.nextResetTime > 0) {
+				// unit:6 TOKENS_LIMIT exists — use API percentage + model-usage tokens
+				weeklyPct = weeklyLimit.percentage ?? 0;
+				weeklyResetAt = weeklyLimit.nextResetTime;
+				const cycleStart = weeklyResetAt - 7 * 24 * 60 * 60 * 1000;
+				weeklyTokens = await this.fetchCycleUsage(origin, headers, cycleStart, now);
+			} else {
+				// No unit:6 — natural week fallback, same as DeepSeek
+				isNaturalWeek = true;
+				weeklyTokens = scanWeeklyTokens(model.provider);
+
+				const d = new Date(now);
+				const dayOfWeek = d.getUTCDay();
+				const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
+				weeklyResetAt = Date.UTC(
+					d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + daysUntilMonday, 0, 0, 0, 0,
+				);
+			}
+
+			return {
+				provider: "zai",
+				tokensLimitPct: fiveHourLimit?.percentage ?? 0,
+				tokensResetAt: fiveHourLimit?.nextResetTime ?? 0,
+				level,
+				weeklyTokens,
+				weeklyResetAt,
+				weeklyPct,
+				isNaturalWeek,
+			};
+		} catch {
+			return null;
+		}
+	}
+
+	formatForFooter(result: NonNullable<ProviderUsageResult>, _sessionCost: number, _currency: string): string {
+		if (result.provider !== "zai") return "";
+		const zai = result as ZaiResult;
+		const parts: string[] = [];
+
+		// 5-hour rolling quota
+		const countdown = formatCountdown(zai.tokensResetAt);
+		parts.push(`Usage ${zai.tokensLimitPct}%(${countdown})`);
+
+		// Weekly quota
+		if (zai.isNaturalWeek) {
+			if (zai.weeklyTokens > 0) {
+				parts.push(`7d:${fmt(zai.weeklyTokens)}`);
+			}
+		} else if (zai.weeklyTokens > 0 || zai.weeklyPct > 0) {
+			const weeklyCountdown = formatWeeklyCountdown(zai.weeklyResetAt);
+			parts.push(`W:${zai.weeklyPct}%(${fmt(zai.weeklyTokens)},${weeklyCountdown})`);
+		}
+
+		return parts.join(" · ");
+	}
+
+	debugDump(result: NonNullable<ProviderUsageResult>, w: (s: string) => void): void {
+		if (result.provider !== "zai") return;
+		const zai = result as ZaiResult;
+		w(`  tokensLimitPct: ${zai.tokensLimitPct}%`);
+		w(`  tokensResetAt: ${new Date(zai.tokensResetAt).toISOString()}`);
+		w(`  level: ${zai.level}`);
+		w(`  weeklyTokens: ${zai.weeklyTokens}`);
+		w(`  weeklyPct: ${zai.weeklyPct}%`);
+		w(`  isNaturalWeek: ${zai.isNaturalWeek}`);
+		w(`  weeklyResetAt: ${zai.weeklyResetAt ? new Date(zai.weeklyResetAt).toISOString() : "?"}`);
+	}
+
+	/** Fetch model-usage for a time range. Returns total tokens. */
+	private async fetchCycleUsage(
+		origin: string,
+		headers: Record<string, string>,
+		cycleStartMs: number,
+		nowMs: number,
+	): Promise<number> {
+		try {
+			const fmtDate = (d: Date) =>
+				`${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")} ${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+			const start = fmtDate(new Date(cycleStartMs));
+			const end = fmtDate(new Date(nowMs));
+			const url = `${origin}/api/monitor/usage/model-usage?startTime=${encodeURIComponent(start)}&endTime=${encodeURIComponent(end)}`;
+			const res = await fetch(url, { headers, signal: AbortSignal.timeout(5000) });
+			if (!res.ok) return 0;
+
+			const usageData = (await res.json()) as {
+				data?: {
+					totalUsage?: { totalTokensUsage?: number };
+					modelSummaryList?: Array<{ modelName: string; totalTokens: number }>;
+				} | Array<{ totalTokens?: number }>;
+			};
+
+			const data = usageData.data;
+			if (!data) return 0;
+			if (Array.isArray(data)) {
+				return data.reduce((sum, e) => sum + (e.totalTokens ?? 0), 0);
+			}
+			if (data.totalUsage?.totalTokensUsage != null) {
+				return data.totalUsage.totalTokensUsage;
+			}
+			if (Array.isArray(data.modelSummaryList)) {
+				return data.modelSummaryList.reduce((sum, e) => sum + (e.totalTokens ?? 0), 0);
+			}
+			return 0;
+		} catch {
+			return 0;
+		}
+	}
+}

package/quota/deepseek.ts

@@ -0,0 +1,31 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { QuotaCalculator, QuotaInfo, WeeklyQuota } from "./types.ts";
+import { scanWeeklyTokens } from "../session-scanner.ts";
+
+export class DeepSeekQuotaCalculator implements QuotaCalculator {
+	async calculate(
+		_modelRegistry: ExtensionContext["modelRegistry"],
+		_model: ExtensionContext["model"],
+	): Promise<QuotaInfo> {
+		const weeklyTokens = scanWeeklyTokens("deepseek");
+
+		// Next Monday 00:00 UTC
+		const now = new Date();
+		const dayOfWeek = now.getUTCDay();
+		const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
+		const nextMonday = new Date(
+			Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0),
+		);
+
+		const weekly: WeeklyQuota = {
+			usedTokens: weeklyTokens,
+			resetAt: nextMonday.getTime(),
+			crossesNaturalWeek: false,
+		};
+
+		return {
+			rolling: null,
+			weekly,
+		};
+	}
+}

package/quota/types.ts

@@ -0,0 +1,34 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Rolling quota window (e.g. ZAI 5-hour token quota) */
+export interface RollingQuota {
+	/** Usage percentage 0–100 */
+	usedPct: number;
+	/** Epoch ms when the window resets */
+	resetAt: number;
+}
+
+/** Weekly subscription quota */
+export interface WeeklyQuota {
+	/** Total tokens used in the subscription week */
+	usedTokens: number;
+	/** Epoch ms when the subscription week resets */
+	resetAt: number;
+	/** Whether resetAt crosses a natural week boundary */
+	crossesNaturalWeek: boolean;
+	/** Usage percentage from unit:6 TOKENS_LIMIT (0 if natural week) */
+	weeklyPct?: number;
+}
+
+/** Provider-specific quota. Fields are null when the provider doesn't support them. */
+export interface QuotaInfo {
+	rolling: RollingQuota | null;
+	weekly: WeeklyQuota | null;
+}
+
+export interface QuotaCalculator {
+	calculate(
+		modelRegistry: ExtensionContext["modelRegistry"],
+		model: ExtensionContext["model"],
+	): Promise<QuotaInfo>;
+}

package/quota/zai.ts

@@ -0,0 +1,90 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { QuotaCalculator, QuotaInfo, WeeklyQuota } from "./types.ts";
+import { scanWeeklyTokens } from "../session-scanner.ts";
+
+export class ZaiQuotaCalculator implements QuotaCalculator {
+	async calculate(
+		modelRegistry: ExtensionContext["modelRegistry"],
+		model: ExtensionContext["model"],
+	): Promise<QuotaInfo> {
+		if (!model || (model.provider !== "zai" && model.provider !== "zai-coding-cn")) {
+			return { rolling: null, weekly: null };
+		}
+
+		const apiKey = await modelRegistry.getApiKeyForProvider(model.provider);
+		if (!apiKey) return { rolling: null, weekly: null };
+
+		const defaultOrigin = model.provider === "zai-coding-cn"
+			? "https://open.bigmodel.cn"
+			: "https://api.z.ai";
+		let origin = defaultOrigin;
+		try { origin = new URL(model.baseUrl ?? defaultOrigin).origin; } catch { /* use default */ }
+
+		const headers: Record<string, string> = {
+			Authorization: apiKey,
+			"Accept-Language": "en-US,en",
+			"Content-Type": "application/json",
+		};
+
+		let rolling: QuotaInfo["rolling"] = null;
+		let weekly: QuotaInfo["weekly"] = null;
+
+		try {
+			const quotaRes = await fetch(`${origin}/api/monitor/usage/quota/limit`, {
+				headers,
+				signal: AbortSignal.timeout(5000),
+			});
+			if (quotaRes.ok) {
+				const quotaData = (await quotaRes.json()) as {
+					data?: {
+						limits?: Array<{
+							type: string;
+							unit?: number;
+							percentage?: number;
+							nextResetTime?: number;
+						}>;
+					};
+				};
+
+				const limits = quotaData.data?.limits ?? [];
+				const fiveHourLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 3);
+				const weeklyLimit = limits.find((l) => l.type === "TOKENS_LIMIT" && l.unit === 6);
+
+				if (fiveHourLimit) {
+					rolling = {
+						usedPct: fiveHourLimit.percentage ?? 0,
+						resetAt: fiveHourLimit.nextResetTime ?? 0,
+					};
+				}
+
+				if (weeklyLimit && weeklyLimit.nextResetTime && weeklyLimit.nextResetTime > 0) {
+					// unit:6 — weekly quota from API
+					weekly = {
+						usedTokens: 0, // actual token count fetched separately by provider
+						resetAt: weeklyLimit.nextResetTime ?? 0,
+						crossesNaturalWeek: true,
+						weeklyPct: weeklyLimit.percentage ?? 0,
+					};
+				} else {
+					// No unit:6 — natural week fallback
+					const weeklyTokens = scanWeeklyTokens(model.provider);
+					const now = new Date();
+					const dayOfWeek = now.getUTCDay();
+					const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
+					const nextMonday = new Date(
+						Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilMonday, 0, 0, 0, 0),
+					);
+					weekly = {
+						usedTokens: weeklyTokens,
+						resetAt: nextMonday.getTime(),
+						crossesNaturalWeek: false,
+					};
+				}
+			}
+		} catch {
+			// quota unavailable
+		}
+
+		return { rolling, weekly };
+	}
+}

package/session-scanner.ts

@@ -0,0 +1,64 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export function scanWeeklyTokens(providerName: string): number {
+	const sessionsDir = join(getAgentDir(), "sessions");
+	const now = new Date();
+	// Natural week: Monday 00:00 UTC
+	const dayOfWeek = now.getUTCDay();
+	const mondayOffset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+	const weekStart = new Date(
+		Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - mondayOffset, 0, 0, 0, 0),
+	);
+
+	let total = 0;
+
+	try {
+		const dirs = readdirSync(sessionsDir, { withFileTypes: true });
+		for (const dir of dirs) {
+			if (!dir.isDirectory()) continue;
+			const dirPath = join(sessionsDir, dir.name);
+			let files: string[];
+			try {
+				files = readdirSync(dirPath);
+			} catch {
+				continue;
+			}
+			for (const fname of files) {
+				if (!fname.endsWith(".jsonl")) continue;
+				try {
+					const fileDate = new Date(fname.slice(0, 10) + "T00:00:00Z");
+					if (fileDate < weekStart) continue;
+				} catch {
+					continue;
+				}
+
+				try {
+					const content = readFileSync(join(dirPath, fname), "utf-8");
+					for (const line of content.split("\n")) {
+						if (!line.trim()) continue;
+						try {
+							const d = JSON.parse(line);
+							if (
+								d.type === "message" &&
+								d.message?.role === "assistant" &&
+								d.message?.provider === providerName
+							) {
+								total += d.message.usage?.totalTokens ?? 0;
+							}
+						} catch {
+							// skip malformed lines
+						}
+					}
+				} catch {
+					// skip unreadable files
+				}
+			}
+		}
+	} catch {
+		// sessions dir doesn't exist or is unreadable
+	}
+
+	return total;
+}

package/token-usage.ts

@@ -0,0 +1,45 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TokenUsage, TokenUsageCalculator } from "./types.ts";
+
+export class SessionTokenUsageCalculator implements TokenUsageCalculator {
+	private getCurrencyOverride: () => "\u00a5" | "$" | undefined;
+
+	constructor(getCurrencyOverride: () => "\u00a5" | "$" | undefined) {
+		this.getCurrencyOverride = getCurrencyOverride;
+	}
+
+	compute(ctx: ExtensionContext): TokenUsage & { cost: number; currency: "\u00a5" | "$" } {
+		let input = 0;
+		let output = 0;
+		let cacheRead = 0;
+		let cacheWrite = 0;
+		let total = 0;
+		let cost = 0;
+
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type === "message" && entry.message.role === "assistant") {
+				const m = entry.message as AssistantMessage;
+				input += m.usage.input;
+				output += m.usage.output;
+				cacheRead += m.usage.cacheRead;
+				cacheWrite += m.usage.cacheWrite;
+				total += m.usage.totalTokens;
+				cost += m.usage.cost.total;
+			}
+		}
+
+		const hitRate = input + cacheRead > 0 ? cacheRead / (input + cacheRead) : 0;
+
+		let currency: "\u00a5" | "$" = "$";
+		const override = this.getCurrencyOverride();
+		if (override) {
+			currency = override;
+		} else {
+			const p = ctx.model?.provider ?? "";
+			if (p.toLowerCase().includes("deepseek")) currency = "\u00a5";
+		}
+
+		return { input, output, cacheRead, cacheWrite, total, hitRate, cost, currency };
+	}
+}

package/types.ts

@@ -0,0 +1,43 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+// ---------------------------------------------------------------------------
+// Token usage
+// ---------------------------------------------------------------------------
+
+export interface TokenUsage {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	total: number;
+	/** cache hit ratio: cacheRead / (input + cacheRead), 0 when denominator is 0 */
+	hitRate: number;
+}
+
+export interface TokenUsageCalculator {
+	compute(ctx: ExtensionContext): TokenUsage & { cost: number; currency: "¥" | "$" };
+}
+
+// ---------------------------------------------------------------------------
+// Provider result types
+// ---------------------------------------------------------------------------
+
+export type DeepSeekResult = {
+	provider: "deepseek";
+	totalBalance: string;
+	currency: string;
+	weeklyTokens: number;
+};
+
+export type ZaiResult = {
+	provider: "zai";
+	tokensLimitPct: number;
+	tokensResetAt: number;
+	level: string;
+	weeklyTokens: number;
+	weeklyResetAt: number;
+	weeklyPct: number;
+	isNaturalWeek: boolean;
+};
+
+export type ProviderUsageResult = DeepSeekResult | ZaiResult | null;