gentle-pi 3.2.0 → 3.2.1

package/tests/review-controller-native-routing.test.ts

@@ -1171,6 +1171,7 @@ for (const statusSchema of [
 
 test("inspect with untrackedScope exclude resolves the intended-untracked stop in one round trip", async (t) => {
 	const { cwd, initial, target, selection } = untrackedStopFixture(t);
+	const baseRef = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
 	const requests: Array<Record<string, unknown>> = [],
 		retained = new Map();
 	const native = {
@@ -1180,7 +1181,11 @@ test("inspect with untrackedScope exclude resolves the intended-untracked stop i
 		},
 	} as unknown as NativeReviewCli;
 	const result = await __testing.executeReviewControllerOperation(
-		{ operation: "inspect", untrackedScope: "exclude" },
+		{
+			operation: "inspect",
+			input: JSON.stringify({ baseRef: "HEAD", committedOnly: true }),
+			untrackedScope: "exclude",
+		},
 		cwd,
 		native,
 		undefined,
@@ -1191,6 +1196,10 @@ test("inspect with untrackedScope exclude resolves the intended-untracked stop i
 	assert.equal(result.status, "ready");
 	assert.equal("selectionBinding" in result, false);
 	assert.equal(requests.length, 2);
+	for (const request of requests) {
+		assert.equal(request.baseRef, baseRef);
+		assert.equal(request.committedOnly, true);
+	}
 	assert.equal(requests[1]!.untrackedScope, "exclude");
 	assert.equal(requests[1]!.expectedUntrackedInventory, SHA);
 	assert.deepEqual(requests[1]!.intendedUntracked, []);
@@ -1960,6 +1969,56 @@ test("ordinary START transports native focus and safe policy inputs without rebu
 	assert.equal(statusCalls, 0);
 });
 
+test("INSPECT forwards an explicit committed-only base selector to negotiated STATUS", async (t) => {
+	const cwd = repository(t);
+	const baseRef = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8" }).trim();
+	const requests: Array<Record<string, unknown>> = [];
+	const native = {
+		targetStatus: async (request: Record<string, unknown>) => {
+			requests.push(request);
+			return startStatus(cwd, baseRef);
+		},
+	} as unknown as NativeReviewCli;
+
+	const result = await __testing.executeReviewControllerOperation(
+		{ operation: "inspect", input: JSON.stringify({ baseRef, committedOnly: true }) },
+		cwd,
+		native,
+	);
+
+	assert.equal(result.status, "ready");
+	assert.deepEqual(
+		requests.map(({ baseRef: selectedBase, committedOnly }) => ({ baseRef: selectedBase, committedOnly })),
+		[{ baseRef, committedOnly: true }],
+	);
+});
+
+test("INSPECT rejects malformed committed-range selectors before negotiated STATUS", async (t) => {
+	const cwd = repository(t);
+	let targetCalls = 0;
+	const native = {
+		targetStatus: async () => {
+			targetCalls += 1;
+			return startStatus(cwd);
+		},
+	} as unknown as NativeReviewCli;
+
+	for (const input of [
+		{ baseRef: "HEAD", committedOnly: false },
+		{ committedOnly: true },
+		{ baseRef: "HEAD", committedOnly: true, mode: "ordinary" },
+	]) {
+		const rejected = await __testing.executeReviewControllerOperation(
+			{ operation: "inspect", input: JSON.stringify(input) },
+			cwd,
+			native,
+		);
+		assert.equal(rejected.outcome, "native-inspect-input-invalid");
+		assert.equal(rejected.mutation_outcome, "none");
+	}
+	assert.equal(targetCalls, 0);
+});
+
 test("ordinary START keeps default and explicit base selection fail-closed before native mutation", async (t) => {
 	const cwd = repository(t);
 	let targetCalls = 0;

package/tests/review-host-relay.test.ts

@@ -214,10 +214,20 @@ const PROMPT_BYTES = Buffer.concat([
 	Buffer.from('GENTLE_AI_REVIEW_BINDING {"lineage":"review-1d5aadacc600e167"}\n"quotes" \\backslash\r\n\u00e9\u{1F3A9}\n', "utf8"),
 	Buffer.from([0x00, 0x01, 0x07, 0xff, 0xfe, 0x00]),
 ]);
-const PI_OUTPUT_BYTES = Buffer.concat([
-	Buffer.from(`{"subject_hash":"sha256:${"a".repeat(64)}","findings":[]}\n`, "utf8"),
-	Buffer.from([0x00, 0xf0, 0x9f, 0x8e, 0xa9, 0xff, 0x0d, 0x0a]),
-]);
+// The reviewer child runs `pi --mode json` and the transport submits the
+// assistant text of that event stream, so the fixture wraps the reviewer
+// payload in the minimal event shape the extraction understands.
+const PI_REVIEWER_TEXT = `{"subject_hash":"sha256:${"a".repeat(64)}","findings":[]}\n🎉\r\n`;
+const piEventStream = (...events: readonly unknown[]): Buffer => Buffer.from(events.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8");
+const assistantEnd = (text: string, reviewerModel?: string) => {
+	const message: Record<string, unknown> = { role: "assistant", content: [{ type: "text", text }] };
+	if (reviewerModel !== undefined) message["model"] = reviewerModel;
+	return { type: "message_end", message };
+};
+const PI_OUTPUT_BYTES = piEventStream(
+	{ type: "message_start", message: { role: "user", content: [] } },
+	assistantEnd(PI_REVIEWER_TEXT),
+);
 
 function relayRequest(fixture: RelayHarness, overrides: Record<string, unknown> = {}) {
 	return {
@@ -293,18 +303,18 @@ test("relay contract constants are the compiled gentle-ai handshake values", ()
 // Happy path
 // ---------------------------------------------------------------------------
 
-test("relay happy path moves prompt and result bytes verbatim through a fresh empty scratch pi subprocess", async (t) => {
+test("relay happy path moves prompt bytes verbatim and the pi event stream's assistant text through a fresh empty scratch pi subprocess", async (t) => {
 	const fixture = harness(t);
 	const result = await runReviewHostRelaySlot(relayRequest(fixture));
 
 	assert.equal(result.promptByteLength, PROMPT_BYTES.length);
-	assert.equal(result.resultByteLength, PI_OUTPUT_BYTES.length);
+	assert.equal(result.resultByteLength, Buffer.byteLength(PI_REVIEWER_TEXT));
 	assert.equal(JSON.parse(result.submission).admission_decision, "completed");
 
 	// Prompt bytes reached pi stdin verbatim.
 	assert.deepEqual(readFileSync(fixture.stdinCapturePath), PROMPT_BYTES);
-	// Submission --input file bytes are EXACTLY the pi stdout bytes.
-	assert.deepEqual(readFileSync(fixture.submitCapturePath), PI_OUTPUT_BYTES);
+	// Submission --input file bytes are EXACTLY the reviewer's assistant text.
+	assert.deepEqual(readFileSync(fixture.submitCapturePath), Buffer.from(PI_REVIEWER_TEXT, "utf8"));
 
 	const gentleAiCalls = readLog(fixture.logPath);
 	assert.equal(gentleAiCalls.length, 2);
@@ -335,13 +345,13 @@ test("relay happy path moves prompt and result bytes verbatim through a fresh em
 	assert.equal(existsSync(piCalls[0]!.cwd!), false);
 });
 
-test("the pi lockdown argv is pinned exactly with no model or provider selection", async (t) => {
+test("the pi lockdown argv is pinned exactly with no default model or provider selection", async (t) => {
 	const fixture = harness(t);
 	await runReviewHostRelaySlot(relayRequest(fixture));
 	const piCalls = readLog(fixture.piLogPath);
 	const expected = [
 		"--print",
-		"--mode", "text",
+		"--mode", "json",
 		"--no-session",
 		"--no-tools",
 		"--no-extensions",
@@ -353,6 +363,8 @@ test("the pi lockdown argv is pinned exactly with no model or provider selection
 	];
 	assert.deepEqual([...REVIEW_HOST_RELAY_PI_ARGV], expected);
 	assert.deepEqual(piCalls[0]!.argv, expected);
+	// The default launch carries no selection; a caller-owned selection may only
+	// ride the validated forwarding path, never the pinned argv.
 	assert.equal(piCalls[0]!.argv.some((token) => token.startsWith("--model") || token.startsWith("--provider") || token.startsWith("--profile")), false);
 });
 
@@ -382,7 +394,7 @@ test("preparation snapshots mutable submission tokens and values before material
 	const result = await prepared;
 	assert.deepEqual(result.request.submission, SUBMISSION);
 	await submitReviewHostRelayPreparedResult(result);
-	assert.deepEqual(readFileSync(fixture.submitCapturePath), PI_OUTPUT_BYTES);
+	assert.deepEqual(readFileSync(fixture.submitCapturePath), Buffer.from(PI_REVIEWER_TEXT, "utf8"));
 });
 
 test("preparation keeps reviewer bytes private through deferred submission", async (t) => {
@@ -430,7 +442,7 @@ test("four reviewers cross a shared barrier before any result submission can beg
 	const prepared = await runReviewHostRelayReviewerGroup(requests);
 
 	assert.equal(prepared.length, REVIEWER_GROUP_LENSES.length);
-	assert.ok(prepared.every((result) => result.resultByteLength === PI_OUTPUT_BYTES.length));
+	assert.ok(prepared.every((result) => result.resultByteLength === Buffer.byteLength(PI_REVIEWER_TEXT)));
 	assert.equal(readLog(fixture.piLogPath).length, REVIEWER_GROUP_LENSES.length);
 	assert.equal(readLog(fixture.logPath).length, REVIEWER_GROUP_LENSES.length, "preparation materializes only; it does not submit");
 });
@@ -527,9 +539,65 @@ test("pi nonzero exit fails closed with a typed error and no submission", async
 
 test("empty pi stdout fails closed with a typed error and no submission", async (t) => {
 	const fixture = harness(t, { RELAY_FAKE_PI_MODE: "empty" });
-	await rejectsWithRelayError(runReviewHostRelaySlot(relayRequest(fixture)), REVIEW_HOST_RELAY_FAILURE.PI_EMPTY_OUTPUT, "pi");
+	const error = await rejectsWithRelayError(runReviewHostRelaySlot(relayRequest(fixture)), REVIEW_HOST_RELAY_FAILURE.PI_EMPTY_OUTPUT, "pi");
 	assert.equal(readLog(fixture.logPath).length, 1);
 	assert.equal(existsSync(fixture.submitCapturePath), false);
+	// #1156: the envelope carries what the child's stream revealed, not just a
+	// bare kind code.
+	assert.match(error.message, /no assistant text|no output|not a pi event stream/);
+});
+
+test("a reviewer run that only attempted a tool call fails typed with the child's own evidence", async (t) => {
+	const fixture = harness(t);
+	const error = await rejectsWithRelayError(runReviewHostRelaySlot(relayRequest(fixture, {
+		environment: {
+			...fixture.environment,
+			RELAY_FAKE_PROMPT_B64: PROMPT_BYTES.toString("base64"),
+			RELAY_FAKE_PI_OUTPUT_B64: piEventStream(
+				{ type: "message_end", message: { role: "assistant", content: [{ type: "toolCall", id: "call_1", name: "bash" }] } },
+				assistantEnd("", "nan/deepseek-v4-flash"),
+			).toString("base64"),
+		},
+	})), REVIEW_HOST_RELAY_FAILURE.PI_EMPTY_OUTPUT, "pi");
+	assert.equal(existsSync(fixture.submitCapturePath), false);
+	assert.match(error.message, /no assistant text/);
+	assert.ok((error as unknown as { reviewerEvidence?: { stdoutKind?: string } }).reviewerEvidence !== undefined, "the failure report must carry the reviewer evidence");
+});
+
+test("the relay forwards the caller-owned reviewer selection and extension allowlist to the child argv", async (t) => {
+	const fixture = harness(t);
+	const adapterPath = join(fixture.directory, "auth-adapter.ts");
+	writeFileSync(adapterPath, "export default () => {};");
+	await runReviewHostRelaySlot(relayRequest(fixture, {
+		reviewerModel: "minimax/MiniMax-M3",
+		reviewerExtensionPaths: [adapterPath],
+	}));
+	const calls = readLog(fixture.piLogPath);
+	assert.equal(calls.length, 1);
+	assert.deepEqual(calls[0]!.argv.slice(-4), ["--model", "minimax/MiniMax-M3", "-e", adapterPath]);
+});
+
+test("a malformed reviewer selection or a relative extension path is refused typed before anything launches", async (t) => {
+	const fixture = harness(t);
+	for (const broken of [
+		{ reviewerModel: "minimax / MiniMax M3" },
+		{ reviewerModel: "" },
+		{ reviewerExtensionPaths: ["relative/auth.ts"] },
+		{ reviewerExtensionPaths: [join(fixture.directory, "missing-adapter.ts")] },
+	]) {
+		let caught: unknown;
+		try {
+			await runReviewHostRelaySlot(relayRequest(fixture, broken));
+		} catch (error) {
+			caught = error;
+		}
+		assert.ok(caught instanceof ReviewHostRelayError, `expected a typed relay error for ${JSON.stringify(broken)}`);
+		const error = caught as ReviewHostRelayError;
+		assert.equal(error.kind, "reviewer-config-invalid");
+		assert.equal(error.stage, "pi");
+		assert.equal(readLog(fixture.piLogPath).length, 0, "no reviewer may launch on a broken selection");
+		assert.equal(readLog(fixture.logPath).length, 0, "no materialization may run on a broken selection");
+	}
 });
 
 test("pi timeout fails closed with a typed error and no submission", async (t) => {
@@ -653,7 +721,8 @@ function admittingRequest(fixture: RelayHarness, reviewerOutput: Buffer) {
 		environment: {
 			...fixture.environment,
 			RELAY_FAKE_PROMPT_B64: PROMPT_BYTES.toString("base64"),
-			RELAY_FAKE_PI_OUTPUT_B64: reviewerOutput.toString("base64"),
+			// The reviewer's payload arrives as the event stream's assistant text.
+			RELAY_FAKE_PI_OUTPUT_B64: piEventStream(assistantEnd(reviewerOutput.toString("utf8"))).toString("base64"),
 		},
 	});
 }

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");