gentle-pi 3.1.1 → 3.2.1

package/tests/review-relay-transport-agent.test.ts

@@ -2,9 +2,10 @@ import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter as pathDelimiter, join } from "node:path";
 import test from "node:test";
 import { __testing } from "../extensions/gentle-ai.ts";
+import { REVIEW_HOST_RELAY_FAILURE, ReviewHostRelayError } from "../lib/review-host-relay.ts";
 import { NativeReviewIntegrationError, type NativeReviewCli } from "../lib/native-review-cli.ts";
 import { CandidateViewRegistry } from "../lib/review-candidate-view.ts";
 import type { ReviewCollectInputV3, ReviewStatusV3 } from "../lib/review-integration-v2.ts";
@@ -186,6 +187,90 @@ test("the negotiated status asks for the pi agent so the provider offers its mat
 	assert.equal(hostRelay.transport, "pi_host_relay");
 });
 
+// gentle-shell#1136 / #1158: the lens's user-owned reviewer selection (agent
+// model routing config) and the extension allowlist environment ride the relay
+// request; without them the child runs the ambient default with no auth
+// adapters. With neither configured the launch stays selection-free.
+test("capture forwards the lens's user-owned reviewer selection and extension allowlist to the relay request", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-config-"));
+	const cwd = repository(t);
+	t.after(() => rmSync(configHome, { recursive: true, force: true }));
+	writeFileSync(join(configHome, "models.json"), JSON.stringify({ "review-reliability": { model: "minimax/MiniMax-M3" } }), "utf8");
+	const adapter = join(configHome, "auth-adapter.ts");
+	const second = join(configHome, "second-adapter.ts");
+	writeFileSync(adapter, "export default () => {};");
+	writeFileSync(second, "export default () => {};");
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousExtensions = process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = [adapter, second].join(pathDelimiter);
+	t.after(() => {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+		if (previousExtensions === undefined) delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
+		else process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = previousExtensions;
+	});
+	const { native } = transportAwareNative();
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	await runCapture(cwd, native, "selection-lineage");
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.reviewerModel, "minimax/MiniMax-M3", "the lens's routing entry must name the child's selection");
+	assert.deepEqual(relayed[0]!.reviewerExtensionPaths, [adapter, second]);
+});
+
+test("capture keeps the relay launch selection-free when the user configured neither a selection nor extensions", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const configHome = mkdtempSync(join(tmpdir(), "gentle-pi-relay-config-empty-"));
+	const cwd = repository(t);
+	t.after(() => rmSync(configHome, { recursive: true, force: true }));
+	const previousConfigHome = process.env.GENTLE_PI_CONFIG_HOME;
+	const previousExtensions = process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
+	t.after(() => {
+		if (previousConfigHome === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previousConfigHome;
+		if (previousExtensions === undefined) delete process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS;
+		else process.env.GENTLE_PI_REVIEW_RELAY_EXTENSIONS = previousExtensions;
+	});
+	const { native } = transportAwareNative();
+	const relayed: ReviewHostRelayRequest[] = [];
+	__testing.setReviewHostRelayRunnerForTesting(async (request: ReviewHostRelayRequest) => {
+		relayed.push(request);
+		return { promptByteLength: 128, resultByteLength: 64, submission: '{"admission_decision":"completed"}' };
+	});
+
+	await runCapture(cwd, native, "default-lineage");
+	assert.equal(relayed.length, 1);
+	assert.equal(relayed[0]!.reviewerModel, undefined);
+	assert.equal(relayed[0]!.reviewerExtensionPaths, undefined);
+});
+
+test("a relayed empty-output failure carries the child's own evidence in the failure report", async (t) => {
+	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
+	const cwd = repository(t);
+	const { native } = transportAwareNative();
+	__testing.setReviewHostRelayRunnerForTesting(async () => {
+		throw new ReviewHostRelayError(REVIEW_HOST_RELAY_FAILURE.PI_EMPTY_OUTPUT, "pi", "pi subprocess produced no assistant text (stdout kind: no-assistant-text; a tool call was attempted)", {
+			reviewerEvidence: { stdoutKind: "no-assistant-text", reviewerModel: "nan/deepseek-v4-flash", toolCallAttempted: true },
+		});
+	});
+
+	const result = await runCapture(cwd, native, "evidence-lineage");
+	assert.equal(result.outcome, "pi-host-relay-transport-failure");
+	const failure = result.failure as { reviewer?: { stdoutKind?: string; reviewerModel?: string; toolCallAttempted?: boolean } } | undefined;
+	assert.ok(failure !== undefined, "the envelope carries the failure report");
+	assert.equal(failure.reviewer?.stdoutKind, "no-assistant-text");
+	assert.equal(failure.reviewer?.reviewerModel, "nan/deepseek-v4-flash");
+	assert.equal(failure.reviewer?.toolCallAttempted, true);
+});
+
 test("capture forecasts the reviewer model run once and spends nothing until it is acknowledged", async (t) => {
 	t.after(() => __testing.setReviewHostRelayRunnerForTesting());
 	const cwd = repository(t);

package/tests/shell-bar.test.ts

@@ -12,6 +12,7 @@ import {
 	type ShellBarModel,
 	type ShellBarTheme,
 } from "../lib/shell-bar.ts";
+import { parseNanQuota } from "../lib/shell-usage.ts";
 
 // The Gentle Shell bar replaces pi's three-line footer with one line of
 // segments. Rendering is pure so it can be verified without a TUI.
@@ -52,6 +53,28 @@ function model(overrides: Partial<ShellBarModel> = {}): ShellBarModel {
 	};
 }
 
+// The grouped NaN fixture the panel test uses, so both surfaces are asserted
+// against the same payload, the same order and the same percentages.
+const GROUPED_NAN_QUOTA = {
+	periodEnd: "2026-10-01T00:00:00.000Z",
+	models: [
+		{ model: "glm5.3-flash", cap: 2_000_000_000, tokensUsed: 200_000_000 },
+		{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 0, periodEnd: "2026-10-17T05:53:20.000Z" },
+		{ model: "glm5.2", cap: 3_000_000_000, tokensUsed: 0, periodEnd: "2026-10-17T05:53:20.000Z" },
+		{ model: "deepseek-v4-flash", cap: 3_000_000_000, tokensUsed: 300_000_000 },
+	],
+};
+
+// The sidebar prints the card body between its borders; the Usage rows are the
+// metered block between the Usage heading and Integrations, minus the context
+// meter, which is not a subscription allowance.
+function sidebarUsageRows(lines: string[]): string[] {
+	const body = lines.filter((line) => line.startsWith("│ ")).map((line) => line.slice(2, -2).trim());
+	const start = body.indexOf("Usage");
+	const end = body.indexOf("Integrations");
+	return body.slice(start + 1, end).filter((line) => /[▰▱]/.test(line) && !line.startsWith("Context"));
+}
+
 test("renderGauge fills cells proportionally to the percentage", () => {
 	assert.equal(renderGauge(45, 8), "▰▰▰▰▱▱▱▱");
 	assert.equal(renderGauge(0, 8), "▱▱▱▱▱▱▱▱");
@@ -81,13 +104,13 @@ test("renderShellBar renders one line with the segments in order", () => {
 	assert.equal(rest.length, 0);
 	assert.equal(
 		line,
-		"✿ gentle-pi ⟡ ~/work/gentle-pi main ⟡ gpt-5.5 · medium ⟡ ctx ▰▰▰▰▱▱▱▱ 45% ⟡ $9.49 sub",
+		"✿ gentle shell ⟡ ~/work/gentle-pi main ⟡ gpt-5.5 · medium ⟡ ctx ▰▰▰▰▱▱▱▱ 45% ⟡ $9.49 sub",
 	);
 });
 
 test("renderShellBar colors the brand, model, effort, and gauge by role", () => {
 	const [line] = renderShellBar(model(), taggedTheme, 400);
-	assert.match(line, /<accent>✿ gentle-pi<\/accent>/);
+	assert.match(line, /<accent>✿ gentle shell<\/accent>/);
 	assert.match(line, /<text>gpt-5\.5<\/text>/);
 	assert.match(line, /<syntaxFunction>medium<\/syntaxFunction>/);
 	assert.match(line, /<accent>▰▰▰▰<\/accent><border>▱▱▱▱<\/border>/);
@@ -120,6 +143,133 @@ test("renderShellBar adds the subscription windows after the cost when usage is
 	assert.match(line, /\$9\.49 sub ⟡ codex 5h ▰▰▰▰▰▱▱▱ 62% · week 31%$/);
 });
 
+test("renderShellBar meters the model the session is using inside a multi-model provider", () => {
+	const usage = {
+		provider: "nan",
+		plan: undefined,
+		fetchedAt: 0,
+		limits: [
+			{ name: "deepseek-v4-flash", limitReached: false, windows: [{ label: "", usedPercent: 18, windowSeconds: 0, resetAt: null, used: 545_000_000, budget: 3_000_000_000 }] },
+			{ name: "glm5.3-flash", limitReached: false, windows: [{ label: "", usedPercent: 10, windowSeconds: 0, resetAt: null, used: 200_000_000, budget: 2_000_000_000 }] },
+		],
+	};
+	const [glm] = renderShellBar(model({ modelId: "glm5.3-flash", usage }), plainTheme, 200);
+	assert.match(glm, /glm5\.3-flash ▰▱▱▱▱▱▱▱ 10%$/);
+	assert.doesNotMatch(glm, /deepseek-v4-flash ▰/);
+	const [other] = renderShellBar(model({ modelId: "deepseek-v4-flash", usage }), plainTheme, 200);
+	assert.match(other, /deepseek-v4-flash ▰▱▱▱▱▱▱▱ 18%$/);
+	const sidebar = renderShellSidebarBar(model({ modelId: "glm5.3-flash", usage }), plainTheme, 60).join("\n");
+	assert.match(sidebar, /glm5\.3-flash +▰▱▱▱▱▱▱▱ +10%/, "the sidebar lists the session model's own allowance");
+});
+
+// The sidebar is the surface that never needs opening, so a provider with
+// per-model allowances shows the panel's model rows there too — most consumed
+// family first, its models inside it — and leaves the aggregate totals and the
+// reset dates to the bar and the panel.
+test("sidebar groups the NaN allowances by subscription without totals or resets", () => {
+	const usage = parseNanQuota(GROUPED_NAN_QUOTA, 0);
+	const lines = renderShellSidebarBar(model({ modelId: "glm5.3-flash", usage }), plainTheme, 60);
+	const rows = sidebarUsageRows(lines);
+	assert.deepEqual(rows.map((row) => row.replace(/\s*[▰▱].*$/, "")), ["deepseek-v4-flash", "glm5.3-flash"]);
+	assert.deepEqual(rows.map((row) => Number.parseInt(row.match(/(\d+)%$/)![1] ?? "", 10)), [10, 10]);
+	assert.equal(rows.some((row) => / 0%$/.test(row)), false, "a window that consumed nothing only spends space");
+	assert.equal(lines.join("\n").includes("total"), false, "an aggregate row only costs space");
+	assert.equal(lines.join("\n").includes("resets in"), false, "the reset dates belong to the panel");
+	for (const width of [24, 46, 60]) {
+		assert.ok(renderShellSidebarBar(model({ usage }), plainTheme, width).every((line) => visibleWidth(line) <= width));
+	}
+});
+
+test("sidebar treats one metered NaN allowance as a per-model provider", () => {
+	const usage = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [{ model: "glm5.3-flash", cap: 2_000_000_000, tokensUsed: 400_000_000, windowHours: 4, windowTokens: 400_000_000, windowTokensUsed: 120_000_000, windowResetsAt: 1_788_620_161 }],
+	}, 0);
+	const lines = renderShellSidebarBar(model({ modelId: "glm5.3-flash", usage }), plainTheme, 60);
+	const rows = sidebarUsageRows(lines).map((row) => row.replace(/\s+/g, " "));
+	// A single allowance is still the panel's rows, not the bar's one-line meter:
+	// the rolling window it reports is a row of its own here too, and the reset
+	// stays in the panel.
+	assert.deepEqual(rows, ["glm5.3-flash ▰▰▱▱▱▱▱▱ 20%", "glm5.3-flash 4h ▰▰▱▱▱▱▱▱ 30%"]);
+	assert.equal(lines.join("\n").includes("resets in"), false);
+});
+
+test("sidebar keeps one aggregate line for a provider without raw allowances", () => {
+	const usage = {
+		provider: "openai-codex",
+		plan: "pro",
+		fetchedAt: 0,
+		limits: [{ name: "codex", limitReached: false, windows: [
+			{ label: "5h", usedPercent: 62, windowSeconds: 18_000, resetAt: null },
+			{ label: "week", usedPercent: 31, windowSeconds: 604_800, resetAt: null },
+		] }],
+	};
+	const lines = renderShellSidebarBar(model({ usage }), plainTheme, 60);
+	assert.deepEqual(sidebarUsageRows(lines), ["codex 5h ▰▰▰▰▰▱▱▱ 62% · week 31%"]);
+});
+
+test("sidebar drops an aggregate allowance that consumed nothing", () => {
+	const usage = {
+		provider: "openai-codex",
+		plan: "pro",
+		fetchedAt: 0,
+		limits: [{ name: "codex", limitReached: false, windows: [
+			{ label: "5h", usedPercent: 0, windowSeconds: 18_000, resetAt: null },
+			{ label: "week", usedPercent: 0, windowSeconds: 604_800, resetAt: null },
+		] }],
+	};
+	const lines = renderShellSidebarBar(model({ usage }), plainTheme, 60);
+	assert.deepEqual(sidebarUsageRows(lines), []);
+	const text = lines.join("\n");
+	assert.match(text, /Usage/);
+	assert.match(text, /Context/);
+	assert.match(text, /Cost/);
+	// The bar keeps its own contract: only the sidebar gives zero rows the boot.
+	assert.match(renderShellBar(model({ usage }), plainTheme, 200)[0], /codex 5h ▱▱▱▱▱▱▱▱ 0% · week 0%$/);
+});
+
+test("sidebar keeps the Usage group when nothing was consumed", () => {
+	const usage = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [
+			{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 0 },
+			{ model: "glm5.2", cap: 3_000_000_000, tokensUsed: 0 },
+		],
+	}, 0);
+	const lines = renderShellSidebarBar(model({ usage }), plainTheme, 60);
+	const text = lines.join("\n");
+	assert.deepEqual(sidebarUsageRows(lines), []);
+	assert.match(text, /Usage/);
+	assert.match(text, /Context/);
+	assert.match(text, /Cost/);
+	assert.match(text, /Integrations/);
+});
+
+test("sidebar hides exactly the rows that would print 0%, rounding included", () => {
+	// The row's own rounding is the only threshold: a fraction below half a
+	// percent is a 0% row and leaves; half a percent keeps its row and prints 1%.
+	const usage = (usedPercent: number) => ({
+		provider: "openai-codex",
+		plan: "pro",
+		fetchedAt: 0,
+		limits: [{ name: "codex", limitReached: false, windows: [{ label: "5h", usedPercent, windowSeconds: 18_000, resetAt: null }] }],
+	});
+	assert.deepEqual(sidebarUsageRows(renderShellSidebarBar(model({ usage: usage(0.4) }), plainTheme, 60)), []);
+	assert.deepEqual(sidebarUsageRows(renderShellSidebarBar(model({ usage: usage(0.5) }), plainTheme, 60)), ["codex 5h ▱▱▱▱▱▱▱▱ 1%"]);
+});
+
+test("sidebar reads a limit without windows as nothing to draw, not as zero consumption", () => {
+	const usage = {
+		provider: "openai-codex",
+		plan: "pro",
+		fetchedAt: 0,
+		limits: [{ name: "codex", limitReached: false, windows: [] }],
+	};
+	const lines = renderShellSidebarBar(model({ usage }), plainTheme, 60);
+	assert.deepEqual(sidebarUsageRows(lines), []);
+	assert.match(lines.join("\n"), /Cost/);
+});
+
 test("renderShellBar shows an unknown context as a question mark after compaction", () => {
 	const [line] = renderShellBar(model({ contextPercent: null }), plainTheme, 160);
 	assert.match(line, /ctx ▱▱▱▱▱▱▱▱ \?%/);
@@ -162,7 +312,7 @@ test("renderShellBar drops the session name, then trailing segments, before trun
 
 	const [atFifty] = renderShellBar(wide, plainTheme, 50);
 	assert.ok(visibleWidth(atFifty) <= 50, `line overflowed: ${visibleWidth(atFifty)}`);
-	assert.match(atFifty, /^✿ gentle-pi/);
+	assert.match(atFifty, /^✿ gentle shell/);
 });
 
 test("shellEnabled stays off inside a Gentle Agents child", () => {

package/tests/shell-usage-view.test.ts

@@ -34,7 +34,8 @@ test("UsageView frames the panel, keeps every line at width, and shows the empty
 	for (const line of lines) assert.equal(visibleWidth(line), 90, `"${stripAnsi(line)}" is not 90 wide`);
 	const plain = lines.map(stripAnsi);
 	assert.match(plain[1], /^│ openai-codex · pro · updated just now +│$/);
-	assert.match(plain[3], /^│ {5}week +▰+▱+ +40% +resets in 2h 0m +│$/);
+	assert.match(plain[2], /^│ {3}codex week +[▰▱]{16} +40% · resets in 2h 0m +│$/);
+	assert.match(plain[3], /r refresh .* esc close/);
 });
 
 test("UsageView refetches on r and closes on escape or q", async () => {
@@ -54,7 +55,7 @@ test("UsageView refetches on r and closes on escape or q", async () => {
 	view.handleInput("r");
 	await new Promise((resolve) => setTimeout(resolve, 0));
 	assert.deepEqual(events, ["render", "refresh", "render"]);
-	assert.match(stripAnsi(view.render(90)[3]), /55%/);
+	assert.match(stripAnsi(view.render(90)[2]), /55%/);
 	assert.match(stripAnsi(view.render(90)[1]), /^│ ✿ openai-codex · pro · updated just now/);
 	view.handleInput("\x1b");
 	view.handleInput("q");

package/tests/shell-usage.test.ts

@@ -6,13 +6,17 @@ import {
 	formatReset,
 	parseAnthropicHeaders,
 	parseCodexHeaders,
+	parseNanQuota,
 	parseUsageHeaders,
 	parseCodexUsage,
+	providerNote,
 	renderUsageBar,
 	renderUsagePanel,
+	SUPPORTED_USAGE_PROVIDERS,
 	UsageStore,
 	windowLabel,
 	type ProviderUsage,
+	type UsageWindow,
 } from "../lib/shell-usage.ts";
 
 // Subscription usage: what each connected provider says about its windows.
@@ -134,11 +138,11 @@ test("renderUsagePanel lists each provider with meters, resets, and a stale mark
 	const lines = renderUsagePanel([usage], plainTheme, 70, NOW + 3 * 60_000);
 	for (const line of lines) assert.ok(visibleWidth(line) <= 70, `too wide: ${line}`);
 	assert.match(lines[0], /^openai-codex · pro · updated 3m ago$/);
-	assert.match(lines[1], /^ {2}codex$/);
-	assert.match(lines[2], /^ {4}week +▰+▱+ +40% +resets in 2d 1h$/);
-	assert.match(lines[3], /^ {2}codex_spark$/);
-	assert.match(lines[4], /^ {4}5h /);
-	assert.match(lines[5], /^ {4}week /);
+	// One row per window: the name, its meter, its percentage and, when the window
+	// reports one, its reset, all on the same line.
+	assert.match(lines[1], /^ {2}codex week +[▰▱]{16} +40% · resets in 2d 1h$/);
+	assert.match(lines[2], /^ {2}codex_spark 5h +[▰▱]{16} +12% · resets in \d+h \d+m$/);
+	assert.match(lines[3], /^ {2}codex_spark week +[▰▱]{16} +3% · resets in \d+d \d+h$/);
 	assert.deepEqual(renderUsagePanel([], plainTheme, 120, NOW), ["No subscription usage yet. Usage arrives with the next response, or press r to fetch it."]);
 });
 
@@ -148,7 +152,7 @@ test("renderUsagePanel puts the active provider first and explains missing data"
 	assert.ok(claude);
 	const both = renderUsagePanel([codex, claude], plainTheme, 100, NOW, { provider: "anthropic" });
 	assert.match(both[0], /^✿ anthropic · updated just now$/);
-	assert.match(both[1], /^ {2}claude$/);
+	assert.match(both[1], /^ {2}claude 5h +[▰▱]{16} +20%$/);
 	assert.match(both.find((line) => line.startsWith("openai-codex")) ?? "", /^openai-codex · pro/);
 
 	const apiKey = renderUsagePanel([codex], plainTheme, 100, NOW, { provider: "openai" });
@@ -160,6 +164,250 @@ test("renderUsagePanel puts the active provider first and explains missing data"
 	assert.deepEqual(renderUsagePanel([], plainTheme, 100, NOW, { provider: "openai-codex" }), ["✿ openai-codex · no usage yet · r to fetch"]);
 });
 
+// NaN Cloud quota: per-model allowances for the billing period, plus the
+// rolling window the model reports. Percentages are tokensUsed over cap, the
+// same ratio the dashboard draws. The payload shape was read off the official
+// dashboard bundle, not a published schema, so every field stays optional.
+const NAN_QUOTA = {
+	periodEnd: "2026-10-01T00:00:00.000Z",
+	models: [
+		{
+			model: "glm5.3",
+			cap: 3_000_000_000,
+			fullCap: 3_000_000_000,
+			tokensUsed: 820_000_000,
+			windowHours: 4,
+			windowTokens: 400_000_000,
+			windowTokensUsed: 120_000_000,
+			windowResetsAt: 1_788_620_161,
+			email: "someone@example.com",
+		},
+		{ model: "deepseek-v4-flash", cap: 1_500_000_000, tokensUsed: 150_000_000 },
+		{ model: "qwen3.8-flash", cap: 0, tokensUsed: 10 },
+	],
+};
+
+// The billing-period window carries no label: the model id in front of it names
+// the allowance, and the reset text says what the window is. Only a sub-window
+// on top (a rolling `4h`) needs a name, so `windowText` spells the unlabeled one
+// out for the assertions below.
+function windowText(window: UsageWindow): string {
+	return `${window.label === "" ? "period" : window.label}:${window.usedPercent}`;
+}
+
+test("parseNanQuota maps each model allowance and its rolling window", () => {
+	const usage = parseNanQuota(NAN_QUOTA, NOW);
+	assert.equal(usage.provider, "nan");
+	assert.equal(usage.plan, undefined);
+	assert.equal(usage.fetchedAt, NOW);
+	assert.deepEqual(usage.limits.map((limit) => limit.name), ["glm5.3", "deepseek-v4-flash"]);
+
+	const [glm, deepseek] = usage.limits;
+	assert.deepEqual(glm.windows.map((window) => window.label), ["", "4h"]);
+	assert.equal(glm.windows[0].usedPercent, (820_000_000 / 3_000_000_000) * 100);
+	assert.equal(glm.windows[0].windowSeconds, 2_212_800);
+	assert.equal(glm.windows[0].resetAt, 1_790_812_800_000);
+	assert.equal(glm.windows[1].usedPercent, 30);
+	assert.equal(glm.windows[1].windowSeconds, 14_400);
+	assert.equal(glm.windows[1].resetAt, 1_788_620_161_000);
+	assert.equal(glm.limitReached, false);
+	assert.deepEqual(deepseek.windows.map(windowText), ["period:10"]);
+	assert.equal(JSON.stringify(usage).includes("example.com"), false, "the quota parser must not keep unrelated account fields");
+});
+
+test("parseNanQuota falls back to the top-level period end and defaults the window budget", () => {
+	const topLevel = parseNanQuota({ periodEnd: 1_790_812_800, models: [{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 0 }] }, NOW);
+	assert.equal(topLevel.limits[0].windows[0].resetAt, 1_790_812_800_000);
+
+	const defaulted = parseNanQuota({ models: [{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 0, windowTokensUsed: 100_000_000 }] }, NOW);
+	assert.deepEqual(defaulted.limits[0].windows.map(windowText), ["period:0", "4h:25"]);
+
+	const overCap = parseNanQuota({ models: [{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 3_000_000_000, windowHours: 12, windowTokensUsed: 60_000_000 }] }, NOW);
+	assert.deepEqual(overCap.limits[0].windows.map(windowText), ["period:100", "12h:15"]);
+	assert.equal(overCap.limits[0].limitReached, true);
+});
+
+test("parseNanQuota degrades to no data instead of throwing", () => {
+	assert.deepEqual(parseNanQuota({}, NOW).limits, []);
+	assert.deepEqual(parseNanQuota(undefined, NOW).limits, []);
+	assert.deepEqual(parseNanQuota({ models: "nope" }, NOW).limits, []);
+	assert.deepEqual(parseNanQuota({ models: [null, "glm5.3", 7] }, NOW).limits, []);
+	assert.deepEqual(parseNanQuota({ models: [{ model: "glm5.3", cap: "3000000000", tokensUsed: 1 }] }, NOW).limits, []);
+	assert.deepEqual(parseNanQuota({ models: [{ model: "glm5.3", cap: 3_000_000_000 }] }, NOW).limits, []);
+	assert.deepEqual(parseNanQuota({ models: [{ model: "", cap: 3_000_000_000, tokensUsed: 1 }] }, NOW).limits, []);
+});
+
+test("nan is a supported usage provider with its own pending note", () => {
+	assert.ok(SUPPORTED_USAGE_PROVIDERS.includes("nan"));
+	assert.equal(providerNote("nan"), "no usage yet · r to fetch");
+	assert.deepEqual(renderUsagePanel([], plainTheme, 100, NOW, { provider: "nan" }), ["✿ nan · no usage yet · r to fetch"]);
+});
+
+test("renderUsagePanel lists each NaN model allowance with its reset on the same row", () => {
+	const usage = parseNanQuota(NAN_QUOTA, NOW);
+	const lines = renderUsagePanel([usage], plainTheme, 80, NOW, { provider: "nan" });
+	for (const line of lines) assert.ok(visibleWidth(line) <= 80, `too wide: ${line}`);
+	assert.match(lines[0], /^✿ nan · updated just now$/);
+	assert.match(lines[1], /^ {2}glm5\.3 +[▰▱]{16} +27% · resets in \d+d \d+h$/);
+	// The rolling window a model reports is a row of its own, with its own reset.
+	assert.match(lines[2], /^ {2}glm5\.3 4h +[▰▱]{16} +30% · resets in \d+h \d+m$/);
+	assert.match(lines[3], /^ {2}deepseek-v4-flash +[▰▱]{16} +10% · resets in \d+d \d+h$/);
+	assert.equal(lines.some((line) => line.includes("total")), false, "an aggregate row only costs space");
+});
+
+// The server picks the order of the per-model allowances, so drawing the first
+// one showed DeepSeek's meter inside a GLM session. The bar follows the model
+// the session actually uses, and falls back to the account total when that
+// model holds no allowance of its own.
+test("renderUsageBar prefers the active model allowance over the payload order", () => {
+	const usage = parseNanQuota(NAN_QUOTA, NOW);
+	assert.equal(renderUsageBar(usage, plainTheme, "deepseek-v4-flash"), "deepseek-v4-flash ▰▱▱▱▱▱▱▱ 10%");
+	assert.equal(renderUsageBar(usage, plainTheme, "glm5.3"), "glm5.3 ▰▰▱▱▱▱▱▱ 27% · 4h 30%");
+	assert.equal(renderUsageBar(usage, plainTheme), "glm5.3 ▰▰▱▱▱▱▱▱ 27% · 4h 30%", "without an active model the first limit still wins");
+	assert.equal(renderUsageBar(usage, plainTheme, "gemma4"), "nan total ▰▰▱▱▱▱▱▱ 22%", "an unmetered model reports the account, never another model");
+	assert.equal(renderUsageBar(usage, plainTheme, "qwen3.8-flash"), "nan total ▰▰▱▱▱▱▱▱ 22%", "a model the payload skips holds no allowance either");
+});
+
+test("renderUsageBar prefers the active model's family before the account total", () => {
+	const usage = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [
+			{ model: "glm5.3-flash", cap: 2_000_000_000, tokensUsed: 200_000_000 },
+			{ model: "deepseek-v4-flash", cap: 4_000_000_000, tokensUsed: 200_000_000 },
+		],
+	}, NOW);
+	// The session model holds no allowance of its own and its family has exactly
+	// one member: the family is still a closer name for the meter than the whole
+	// account, so the ladder visits it before the account rung.
+	assert.match(renderUsageBar(usage, plainTheme, "glm5.3-turbo") ?? "", /^glm total ▰▱▱▱▱▱▱▱ 10%$/);
+	assert.match(renderUsageBar(usage, plainTheme, "gemma4") ?? "", /^nan total ▰▱▱▱▱▱▱▱ 7%$/, "no member of the family means the account is the only honest name");
+});
+
+test("a single metered allowance still takes the family and account names", () => {
+	const usage = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [
+			{ model: "glm5.3-flash", cap: 2_000_000_000, tokensUsed: 400_000_000 },
+			{ model: "gemma4", cap: 0 },
+		],
+	}, NOW);
+	// One metered model is still a payload that carries raw allowances, so the bar
+	// names the allowance the session draws from instead of listing whichever
+	// model the payload happened to report.
+	assert.deepEqual(usage.limits.map((limit) => limit.name), ["glm5.3-flash"]);
+	assert.equal(renderUsageBar(usage, plainTheme, "glm5.3-flash"), "glm5.3-flash ▰▰▱▱▱▱▱▱ 20%");
+	assert.match(renderUsageBar(usage, plainTheme, "glm5.4") ?? "", /^glm total ▰▰▱▱▱▱▱▱ 20%$/);
+	assert.match(renderUsageBar(usage, plainTheme, "gemma4") ?? "", /^nan total ▰▰▱▱▱▱▱▱ 20%$/);
+});
+
+test("renderUsageBar leaves providers without raw allowances on their first limit", () => {
+	assert.equal(renderUsageBar(parseCodexUsage(CODEX_PAYLOAD, NOW), plainTheme, "gpt-5.2-codex"), "codex week ▰▰▰▱▱▱▱▱ 40%");
+});
+
+test("parseNanQuota weights the period window by the effective allowance", () => {
+	const usage = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [
+			{ model: "glm5.3-flash", cap: 1_500_000_000, fullCap: 2_000_000_000, tokensUsed: 200_000_000 },
+			{ model: "glm5.3", cap: 0, fullCap: 3_000_000_000, tokensUsed: 300_000_000 },
+		],
+	}, NOW);
+	// The dashboard divides by the full-period allowance, not by the prorated cap
+	// the current period reports, so the percentages keep matching it.
+	assert.deepEqual(usage.limits.map((limit) => limit.name), ["glm5.3-flash", "glm5.3"]);
+	const [prorated, noPeriodCap] = usage.limits;
+	assert.equal(prorated.windows[0].budget, 2_000_000_000, "fullCap is the denominator when it is positive");
+	assert.equal(prorated.windows[0].usedPercent, 10);
+	assert.equal(noPeriodCap.windows[0].budget, 3_000_000_000, "a period cap prorated to zero still reports a metered model");
+	assert.equal(noPeriodCap.windows[0].usedPercent, 10);
+	assert.equal(noPeriodCap.limitReached, false);
+});
+
+test("parseNanQuota refuses a payload that hides a metered model's usage", () => {
+	// A sibling with a metered allowance whose usage cannot be read is drift, not
+	// a model to skip: a partial snapshot would understate every aggregate it
+	// feeds, so the read fails whole and the last valid snapshot survives.
+	const drifted = parseNanQuota({
+		periodEnd: "2026-10-01T00:00:00.000Z",
+		models: [
+			{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 820_000_000 },
+			{ model: "deepseek-v4-flash", cap: 2_000_000_000 },
+		],
+	}, NOW);
+	assert.deepEqual(drifted.limits, []);
+	// No allowance at all is not drift: the dashboard draws nothing for these
+	// models either, and today's real payload carries them.
+	const unmetered = parseNanQuota({
+		models: [
+			{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 820_000_000 },
+			{ model: "gemma4", cap: 0 },
+			{ model: "qwen3.8-flash", tokensUsed: 10 },
+		],
+	}, NOW);
+	assert.deepEqual(unmetered.limits.map((limit) => limit.name), ["glm5.3"]);
+	assert.deepEqual(parseNanQuota({ models: "none" }, NOW).limits, []);
+});
+
+test("parseNanQuota keeps the raw numbers the aggregates are weighted by", () => {
+	const [glm] = parseNanQuota(NAN_QUOTA, NOW).limits;
+	assert.equal(glm.windows[0].used, 820_000_000);
+	assert.equal(glm.windows[0].budget, 3_000_000_000);
+	const [codex] = parseCodexUsage(CODEX_PAYLOAD, NOW).limits[0].windows;
+	assert.equal(codex.used, undefined, "only NaN reports raw allowance numbers, which is what gates the aggregates");
+	assert.equal(codex.budget, undefined);
+});
+
+// Grouping is a presentation decision: the panel adds the account total and one
+// row per family with more than one metered model, and each of those rows is an
+// ordinary limit block, the shape Codex already uses for its extra limits.
+const GROUPED_NAN_QUOTA = {
+	periodEnd: "2026-10-01T00:00:00.000Z",
+	models: [
+		{ model: "glm5.3-flash", cap: 2_000_000_000, tokensUsed: 200_000_000 },
+		{ model: "glm5.3", cap: 3_000_000_000, tokensUsed: 0, periodEnd: "2026-10-17T05:53:20.000Z" },
+		{ model: "glm5.2", cap: 3_000_000_000, tokensUsed: 0, periodEnd: "2026-10-17T05:53:20.000Z" },
+		{ model: "deepseek-v4-flash", cap: 3_000_000_000, tokensUsed: 300_000_000 },
+	],
+};
+
+function panelNames(lines: string[]): string[] {
+	return lines.filter(isMeterRow).map((line) => line.trim().replace(/\s*[▰▱].*$/, ""));
+}
+
+// A meter row carries the row name and its gauge on one line; the reset, when the
+// window reports one, is the line underneath.
+function isMeterRow(line: string): boolean {
+	return /[▰▱]/.test(line);
+}
+
+// A row carries its own reset on the same line when the window reports one.
+function panelResets(lines: string[]): string[] {
+	return lines.filter(isMeterRow).map((line) => /resets in .*$/.exec(line)?.[0] ?? "").filter((reset) => reset.length > 0);
+}
+
+function panelPercents(lines: string[]): number[] {
+	return lines.filter(isMeterRow).map((line) => Number.parseInt(line.trim().match(/(\d+)%/)![1] ?? "", 10));
+}
+
+test("renderUsagePanel orders the NaN allowances by family and prints no totals", () => {
+	const lines = renderUsagePanel([parseNanQuota(GROUPED_NAN_QUOTA, NOW)], plainTheme, 80, NOW, { provider: "nan" }).map((line) => line.trimEnd());
+	assert.deepEqual(panelNames(lines), ["deepseek-v4-flash", "glm5.3-flash", "glm5.3", "glm5.2"]);
+	// 300M of 3B for DeepSeek first, then the GLM family by its own allowance.
+	assert.deepEqual(panelPercents(lines), [10, 10, 0, 0]);
+	// Every row keeps its own reset, inline: one line per window, never two.
+	const resets = panelResets(lines);
+	assert.equal(resets.length, 4);
+	assert.equal(resets[0], resets[1], "the two models on the 2026-10-01 period share their date");
+	assert.equal(resets[2], resets[3], "the two models on the 2026-10-17 period share theirs");
+	assert.notEqual(resets[1], resets[2], "each row carries its own window's reset, not its family's");
+});
+
+test("renderUsagePanel leaves providers without raw allowances ungrouped", () => {
+	const lines = renderUsagePanel([parseCodexUsage(CODEX_PAYLOAD, NOW)], plainTheme, 70, NOW);
+	assert.equal(lines.some((line) => line.includes("total")), false);
+	assert.match(lines[1], /^ {2}codex week /);
+});
+
 test("UsageStore keeps the latest snapshot per provider and lists them in order", () => {
 	const store = new UsageStore();
 	const first: ProviderUsage = { provider: "openai-codex", plan: "pro", limits: [], fetchedAt: 1 };