gentle-pi 3.7.0 → 4.0.0

package/tests/shell-todo.test.ts

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import test, { after, before, type TestContext } from "node:test";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import {
 	applyTodo,
@@ -12,6 +12,7 @@ import {
 	todoSummary,
 	type TodoState,
 } from "../lib/shell-todo.ts";
+import { CARD_STYLE, cardStyle, setCardStyle, type CardStyle } from "../lib/shell-card.ts";
 import { stripAnsi } from "../lib/terminal-theme.ts";
 
 // Gentle Todo: a task list the model rewrites as it works. The reducer is
@@ -27,6 +28,42 @@ const plainTheme = {
 	},
 };
 
+// The card style defaults to float; these assertions pin the outlined (neon)
+// panels unless a test switches the style itself.
+const initialCardStyle = cardStyle();
+before(() => setCardStyle(CARD_STYLE.NEON));
+after(() => setCardStyle(initialCardStyle));
+
+function useCardStyle(t: TestContext, style: CardStyle): void {
+	const found = cardStyle();
+	t.after(() => setCardStyle(found));
+	setCardStyle(style);
+}
+
+const BG_OPEN = "\x1b[48;5;22m";
+const BG_CLOSE = "\x1b[49m";
+
+/** The same theme with a background, so the float style applies (without one panels keep the frame). */
+function withBackground<T extends object>(theme: T): T & { bg(color: string, text: string): string } {
+	return { ...theme, bg: (_color: string, text: string) => `${BG_OPEN}${text}${BG_CLOSE}` };
+}
+
+/** Float panel rows: a painted panel inside transparent one-column margins, between padding rows that keep the accent bar. */
+function assertFloatRows(lines: readonly string[], width: number): void {
+	for (const line of lines) {
+		assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+		assert.ok(line.startsWith(` ${BG_OPEN}`) && line.endsWith(`${BG_CLOSE} `), `painted inside the margins: ${JSON.stringify(line)}`);
+	}
+	const padding = ` ▎${" ".repeat(width - 3)} `;
+	assert.equal(stripAnsi(lines[0]!), padding, "a padding row with the accent bar sits above the header");
+	assert.equal(stripAnsi(lines.at(-1)!), padding, "a padding row with the accent bar replaces the bottom rule");
+}
+
+/** The text of a body row, without the neon side rails or the float accent bar. */
+function bodyText(row: string): string {
+	return stripAnsi(row).replace(/^ ?[│▎] /u, "").replace(/ ?│? ?$/u, "").trimEnd();
+}
+
 function seeded(): TodoState {
 	return applyTodo(
 		emptyTodo(),
@@ -293,3 +330,52 @@ test("renderTodoCard uses custom shortcuts, omits disabled shortcuts, and remain
 		for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
 	}
 });
+
+test("renderTodoCard in the float style keeps its clickable control on the header row, one row below the top padding, above a separator row", (t) => {
+	const theme = withBackground(plainTheme);
+	for (const options of [
+		{ collapsed: false, staleTurns: 0, collapseKey: "ctrl+shift+t" },
+		{ collapsed: true, staleTurns: 0, collapseKey: "ctrl+shift+t" },
+		{ collapsed: false, staleTurns: 4 },
+		{ collapsed: false, staleTurns: 0, scrollable: true },
+	]) {
+		const neon = renderTodoCard(seeded(), theme, 60, options);
+		useCardStyle(t, CARD_STYLE.FLOAT);
+		const float = renderTodoCard(seeded(), theme, 60, options);
+		setCardStyle(CARD_STYLE.NEON);
+		assert.equal(float.length, neon.length + 2, "the top padding and separator rows add two rows");
+		const action = options.collapsed ? "▸ Expand" : "▾ Collapse";
+		const hint = options.collapseKey ? `ctrl\\+shift\\+t {3}` : "";
+		assert.match(stripAnsi(float[1]!), new RegExp(`^ ▎ ❀ Todos ${action}  1 of 3 +${hint}$`), "row 1 is the clickable header");
+		assert.match(stripAnsi(float[2]!), /^ ▎ +$/, "a blank separator row follows the header");
+		assertFloatRows(float, 60);
+		assert.deepEqual(float.slice(3, -1).map(bodyText), neon.slice(1, -1).map(bodyText));
+	}
+	useCardStyle(t, CARD_STYLE.FLOAT);
+	const tagged = withBackground({ ...plainTheme, fg: (color: string, text: string) => `<${color}>${text}</${color}>` });
+	const [, header] = renderTodoCard(seeded(), tagged, 120, { collapsed: false, staleTurns: 0, hovered: true });
+	assert.match(stripAnsi(header!), /^ <border>▎<\/border> <accent>❀ Todos <[a-zA-Z]+>▾ Collapse<\/[a-zA-Z]+><\/accent>  <muted>1 of 3<\/muted> +$/, "the hovered control keeps its own role and case");
+});
+
+test("float Todos keeps the configured shortcut visible at rail width without repeating the action", (t) => {
+	useCardStyle(t, CARD_STYLE.FLOAT);
+	const theme = withBackground(plainTheme);
+	for (const collapsed of [false, true]) {
+		for (const collapseKey of ["ctrl+shift+t", "alt+t", undefined]) {
+			const rows = renderTodoCard(seeded(), theme, 48, { collapsed, staleTurns: 0, collapseKey });
+			const header = stripAnsi(rows[1]!);
+			assert.match(header, collapsed ? /▸ Expand/ : /▾ Collapse/);
+			if (collapseKey) assert.ok(header.includes(collapseKey));
+			else assert.doesNotMatch(header, /ctrl\+shift\+t|alt\+t/);
+			assert.equal(visibleWidth(rows[1]!), 48);
+		}
+	}
+});
+
+test("a done todo wraps to the float body so the strikethrough never re-wraps", (t) => {
+	useCardStyle(t, CARD_STYLE.FLOAT);
+	const state = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "word ".repeat(20).trim(), status: "done" }] }, 1).state;
+	const lines = renderTodoCard(state, withBackground(plainTheme), 40, { collapsed: false, staleTurns: 0 });
+	assertFloatRows(lines, 40);
+	for (const row of lines.slice(3, -1)) assert.match(stripAnsi(row), /^ ▎ [✓ ] ~[^~]+~ +$/u, "each physical row closes its own strikethrough");
+});

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

@@ -62,6 +62,33 @@ test("UsageView refetches on r and closes on escape or q", async () => {
 	assert.equal(events.filter((event) => event === "close").length, 2);
 });
 
+test("UsageView starts a refresh at open and repaints when it settles", async () => {
+	const store = new UsageStore();
+	const events: string[] = [];
+	let resolveRefresh: (() => void) | undefined;
+	const view = new UsageView(store, {
+		theme: plainTheme,
+		now: () => NOW,
+		active: () => undefined,
+		onRefresh: () =>
+			new Promise<void>((resolve) => {
+				events.push("refresh");
+				resolveRefresh = resolve;
+			}),
+		onClose: () => events.push("close"),
+		requestRender: () => events.push("render"),
+	});
+	view.refresh();
+	assert.deepEqual(events, ["render", "refresh"], "opening the panel dispatches the refresh instead of waiting for it");
+	assert.match(stripAnsi(view.render(90)[0]), /✿ Subscriptions · refreshing…/, "the panel says it is refreshing while the dispatch is in flight");
+	store.record(parseCodexUsage(payload(40), NOW));
+	resolveRefresh!();
+	await new Promise((resolve) => setTimeout(resolve, 0));
+	assert.deepEqual(events, ["render", "refresh", "render"], "settling repaints once");
+	assert.match(stripAnsi(view.render(90)[0]), /^╭─ ✿ Subscriptions ─+╮$/, "the title returns once the refresh settles");
+	assert.match(stripAnsi(view.render(90)[2]), /40%/, "the settled snapshot is drawn");
+});
+
 function click(x: number, y: number, width: number, height: number): TuiMouseEvent {
 	return { type: "click", button: "left", x, y, screenX: x, screenY: y, width, height, shift: false, alt: false, ctrl: false };
 }

package/tests/shell-usage.test.ts

@@ -15,6 +15,7 @@ import {
 	renderUsageBar,
 	renderUsagePanel,
 	SUPPORTED_USAGE_PROVIDERS,
+	usageScopeProviders,
 	UsageSourceRegistry,
 	USAGE_SOURCE_SCHEMA,
 	UsageStore,
@@ -572,3 +573,75 @@ test("parseUsageHeaders picks whichever provider the headers belong to", () => {
 	assert.equal(parseUsageHeaders({ "anthropic-ratelimit-unified-5h-utilization": "0.1" }, NOW)?.provider, "anthropic");
 	assert.equal(parseUsageHeaders({ "content-type": "application/json" }, NOW), undefined);
 });
+
+// Targeted providers: the session's own provider plus every provider the
+// active profile's subagent routing names. A qualified ref ("provider/id")
+// resolves directly; a bare model id resolves only through the registry
+// callback, so an ambiguous ref is dropped instead of guessed.
+
+test("usageScopeProviders targets the main provider and every qualified routing provider", () => {
+	assert.deepEqual(
+		usageScopeProviders("openai-codex", ["nan/glm5.3", "openai-codex/gpt-5.5", undefined], undefined),
+		["openai-codex", "nan"],
+	);
+});
+
+test("usageScopeProviders resolves bare model ids only through the registry callback", () => {
+	assert.deepEqual(usageScopeProviders(undefined, ["glm5.3"], (id) => (id === "glm5.3" ? "nan" : undefined)), ["nan"]);
+	assert.deepEqual(
+		usageScopeProviders(undefined, ["glm5.3", "mystery"], () => undefined),
+		[],
+		"an id the registry cannot resolve to exactly one provider is dropped, never guessed",
+	);
+});
+
+function scopePanel(usages: ProviderUsage[], providers: string[], failed: string[] = []): string[] {
+	return renderUsagePanel(usages, plainTheme, 100, NOW, { provider: "openai-codex" }, undefined, {
+		providers,
+		failed: new Set(failed),
+	});
+}
+
+test("renderUsagePanel draws the targeted scope in scope order with no-data and failed-fetch notes", () => {
+	const codex = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	const nan = parseNanQuota(NAN_QUOTA, NOW);
+	const lines = scopePanel([nan, codex], ["openai-codex", "nan", "acme-cloud"], ["acme-cloud"]);
+	assert.match(lines[0], /^✿ openai-codex · pro/);
+	assert.match(lines.find((line) => line.startsWith("nan")) ?? "", /^nan · /, "a targeted provider with data renders like any other");
+	assert.match(lines.find((line) => line.startsWith("acme-cloud")) ?? "", /^acme-cloud · fetch failed · r to retry$/);
+});
+
+test("renderUsagePanel keeps a headers-only targeted provider pending, never a false failure", () => {
+	const pending = (providers: string[], failed: string[] = []) =>
+		renderUsagePanel([], plainTheme, 100, NOW, undefined, undefined, { providers, failed: new Set(failed) });
+	assert.deepEqual(
+		pending(["anthropic"]),
+		["anthropic · usage arrives with the first response"],
+	);
+	assert.deepEqual(
+		pending(["openai-codex"]),
+		["openai-codex · no usage yet · r to fetch"],
+		"an unattempted fetch still says pending, not failed",
+	);
+	assert.deepEqual(
+		pending(["openai-codex"], ["openai-codex"]),
+		["openai-codex · fetch failed · r to retry"],
+	);
+});
+
+test("renderUsagePanel never presents a provider outside the current scope after a profile switch", () => {
+	const codex = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	const nan = parseNanQuota(NAN_QUOTA, NOW);
+	const lines = scopePanel([nan, codex], ["openai-codex"]);
+	assert.ok(lines.some((line) => line.startsWith("✿ openai-codex · pro")));
+	assert.equal(lines.some((line) => line.startsWith("nan ·")), false, "the previous profile's provider is not current scope");
+});
+
+test("renderUsagePanel renders the failure note beside a retained snapshot, and only after a real failure", () => {
+	const codex = parseCodexUsage(CODEX_PAYLOAD, NOW);
+	const afterFailure = scopePanel([codex], ["openai-codex"], ["openai-codex"]);
+	assert.match(afterFailure[0], /^✿ openai-codex · pro/, "the retained snapshot stays the provider's headline");
+	assert.match(afterFailure[1], /^ {2}codex week /, "the last good snapshot survives the failed refresh");
+	assert.ok(afterFailure.some((line) => /^ {2}fetch failed · r to retry$/.test(line)), "the failure is visible beside the retained snapshot");
+	assert.equal(scopePanel([codex], ["openai-codex"]).some((line) => line.includes("fetch failed")), false, "a provider whose latest refresh succeeded carries no failure note");
+});

package/tests/skill-registry.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, statSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, symlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -316,3 +317,51 @@ test("non-forced regeneration invalidates cache when skill bytes change but path
 	assert.match(secondRegistry, /Variant two\. Body B\./);
 	assert.doesNotMatch(secondRegistry, /Variant one\. Body A\./);
 });
+
+test("ensureAtlIgnored creates .atl/.gitignore with * and leaves root .gitignore untouched (#1387)", async (t) => {
+	const cwd = mkdtempSync(join(tmpdir(), `gentle-pi-git-atl-${Date.now()}-`));
+	t.after(() => rmSync(cwd, { recursive: true, force: true }));
+
+	// Initialize real git repo with a commit
+	execSync("git init", { cwd, stdio: "ignore" });
+	writeFileSync(join(cwd, "README.md"), "# Test\n");
+	execSync("git add README.md && git -c user.name='Test' -c user.email='test@example.com' commit -m \"initial\"", { cwd, stdio: "ignore" });
+
+	const rootGitignore = join(cwd, ".gitignore");
+	const atlGitignore = join(cwd, ".atl", ".gitignore");
+
+	// Run ensureAtlIgnored
+	await __testing.ensureAtlIgnored(cwd);
+
+	// Root .gitignore must NOT be created
+	assert.equal(existsSync(rootGitignore), false, "root .gitignore must not be created");
+
+	// .atl/.gitignore must exist with * rule
+	assert.equal(existsSync(atlGitignore), true, ".atl/.gitignore must exist");
+	assert.equal(readFileSync(atlGitignore, "utf8").trim(), "*");
+
+	// Write generated registry file inside .atl
+	writeFileSync(join(cwd, ".atl", "skill-registry.md"), "## Skills\n");
+
+	// Verify that git status reports no untracked files
+	const status = execSync("git status --porcelain", { cwd, encoding: "utf8" });
+	assert.equal(status.trim(), "", ".atl/ files must not appear in git status");
+
+	// Idempotency: calling ensureAtlIgnored again does not duplicate or alter the rule
+	await __testing.ensureAtlIgnored(cwd);
+	assert.equal(readFileSync(atlGitignore, "utf8").trim(), "*");
+
+	// Existing root .gitignore is preserved unmodified
+	writeFileSync(rootGitignore, "node_modules/\n");
+	await __testing.ensureAtlIgnored(cwd);
+	assert.equal(readFileSync(rootGitignore, "utf8"), "node_modules/\n", "existing root .gitignore must remain untouched");
+
+	// If .atl/.gitignore already has intermediate rules ending with a negation, ensure * is appended
+	writeFileSync(atlGitignore, "*\n!*.md\n");
+	await __testing.ensureAtlIgnored(cwd);
+	const updatedRules = readFileSync(atlGitignore, "utf8")
+		.split("\n")
+		.map((l) => l.trim())
+		.filter((l) => l !== "" && !l.startsWith("#"));
+	assert.equal(updatedRules.at(-1), "*", "final active ignore rule must be *");
+});

package/tests/startup-banner.test.ts

@@ -5,7 +5,7 @@ import fs from "node:fs/promises";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import startup, { readGitBranch } from "../extensions/startup-banner.ts";
+import startup, { isPiCliSubcommandInvocation, readGitBranch } from "../extensions/startup-banner.ts";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../lib/terminal-theme.ts";
@@ -210,6 +210,12 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 	test(`startup art respects rose=${showRose}, logo=${showTextLogo} and cyan palette`, async (t) => {
 		t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
 		t.mock.method(fs, "readFile", async () => JSON.stringify({ showRose, showTextLogo, color: "cyan" }));
+		t.mock.method(fs, "readdir", async () => [
+			{ name: "sdd-apply.md", isFile: () => true },
+			{ name: "sdd-status.md", isFile: () => true },
+			{ name: "gentle-ai-worker.md", isFile: () => true },
+			{ name: "notes.txt", isFile: () => true },
+		] as any);
 		syncBuiltinESMExports();
 		t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
 		const argv = process.argv;
@@ -233,7 +239,8 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 		await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
 			header = factory({ requestRender() {} }, { fg: (_role: string, text: string) => text });
 		} } });
-		t.mock.timers.tick(50);
+		t.mock.timers.tick(200);
+		for (let i = 0; i < 5; i++) await Promise.resolve();
 		try {
 			for (const width of [40, 80, 160, 200]) {
 				const lines = header!.render(width);
@@ -241,6 +248,8 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 				const text = stripAnsi(lines.join("\n"));
 				assert.match(text, /GIT:/);
 				assert.match(text, /PATH:/);
+				assert.doesNotMatch(text, /phases\b/i, "historical SDD files never appear as active phases");
+				assert.match(text, /AGENTS:\s+1 agents/, "only the installed background agent is counted");
 				if (width >= 160) {
 					assert.equal(/[\u2800-\u28ff]/.test(text), showRose);
 					assert.equal(/[▒▄▀█]/.test(text), showTextLogo);
@@ -268,3 +277,122 @@ for (const showRose of [false, true]) for (const showTextLogo of [false, true])
 		}
 	});
 }
+
+test("startup banner counts MCP servers from the active Pi agent dir", async (t) => {
+	const agentDir = join(tmpdir(), "gp-banner-agent-dir");
+	const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+	process.env.PI_CODING_AGENT_DIR = agentDir;
+	t.after(() => {
+		if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+		else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+	});
+	t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+	// Only the active agent dir's mcp.json declares two servers; any other
+	// mcp.json (for example ~/.pi/agent/mcp.json) declares five.
+	t.mock.method(fs, "readFile", async (path: string) => {
+		if (String(path) === join(agentDir, "mcp.json")) return JSON.stringify({ mcpServers: { one: {}, two: {} } });
+		if (String(path).endsWith("mcp.json")) return JSON.stringify({ mcpServers: { a: {}, b: {}, c: {}, d: {}, e: {} } });
+		return JSON.stringify({ showRose: false, showTextLogo: false, color: "pink" });
+	});
+	t.mock.method(fs, "readdir", async () => [] as any);
+	syncBuiltinESMExports();
+	t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+	const argv = process.argv;
+	process.argv = ["node"];
+	t.after(() => { process.argv = argv; });
+	for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+		const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+		Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+		t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+	}
+	let start: Function;
+	let shutdown: Function;
+	let header: { render(width: number): string[]; dispose(): void };
+	const { default: coldStartup } = await import(new URL("../extensions/startup-banner.ts?mcp-agent-dir", import.meta.url).href) as typeof import("../extensions/startup-banner.ts");
+	coldStartup({ on: (name: string, fn: Function) => {
+		if (name === "session_start") start = fn;
+		if (name === "session_shutdown") shutdown = fn;
+	}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+	await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+		header = factory({ requestRender() {} }, { fg: (_role: string, text: string) => text });
+	} } });
+	t.mock.timers.tick(200);
+	for (let i = 0; i < 5; i++) await Promise.resolve();
+	try {
+		assert.match(stripAnsi(header!.render(160).join("\n")), /MCP:\s+2 server\(s\)/);
+	} finally {
+		header!.dispose();
+		shutdown!();
+	}
+});
+
+test("startup banner counts packages, extensions and agents from the active Pi agent dir", async (t) => {
+	const agentDir = join(tmpdir(), "gp-banner-active-agent-dir");
+	const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+	process.env.PI_CODING_AGENT_DIR = agentDir;
+	t.after(() => {
+		if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+		else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+	});
+	t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+	// The active agent dir declares one package with two extensions and three
+	// agents; any other agent dir (for example ~/.pi/agent) declares more.
+	t.mock.method(fs, "readFile", async (path: string) => {
+		const file = String(path);
+		if (file === join(agentDir, "settings.json")) return JSON.stringify({ packages: ["npm:@acme/pi-kit@1.0.0"] });
+		if (file.endsWith("settings.json")) return JSON.stringify({ packages: ["npm:a", "npm:b", "npm:c", "npm:d"] });
+		if (file === join(agentDir, "npm", "node_modules", "@acme/pi-kit", "package.json")) {
+			return JSON.stringify({ pi: { extensions: ["one.ts", "two.ts"] } });
+		}
+		if (file.endsWith("package.json")) return JSON.stringify({ pi: { extensions: ["x.ts", "y.ts", "z.ts", "w.ts", "v.ts"] } });
+		if (file.endsWith("mcp.json")) return JSON.stringify({ mcpServers: {} });
+		return JSON.stringify({ showRose: false, showTextLogo: false, color: "pink" });
+	});
+	const agentFile = (name: string) => ({ name, isFile: () => true });
+	t.mock.method(fs, "readdir", async (path: string) => String(path) === join(agentDir, "agents")
+		? [agentFile("one.md"), agentFile("two.md"), agentFile("three.md"), agentFile("sdd-apply.md")] as any
+		: [agentFile("a.md"), agentFile("b.md"), agentFile("c.md"), agentFile("d.md"), agentFile("e.md"), agentFile("f.md"), agentFile("g.md")] as any);
+	syncBuiltinESMExports();
+	t.after(() => { t.mock.restoreAll(); syncBuiltinESMExports(); });
+	const argv = process.argv;
+	process.argv = ["node"];
+	t.after(() => { process.argv = argv; });
+	for (const [key, value] of [["rows", 40], ["columns", 160]] as const) {
+		const descriptor = Object.getOwnPropertyDescriptor(process.stdout, key);
+		Object.defineProperty(process.stdout, key, { configurable: true, writable: true, value });
+		t.after(() => descriptor ? Object.defineProperty(process.stdout, key, descriptor) : Reflect.deleteProperty(process.stdout, key));
+	}
+	let start: Function;
+	let shutdown: Function;
+	let header: { render(width: number): string[]; dispose(): void };
+	const { default: coldStartup } = await import(new URL("../extensions/startup-banner.ts?active-agent-dir-counts", import.meta.url).href) as typeof import("../extensions/startup-banner.ts");
+	coldStartup({ on: (name: string, fn: Function) => {
+		if (name === "session_start") start = fn;
+		if (name === "session_shutdown") shutdown = fn;
+	}, registerCommand() {}, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+	await start!({}, { hasUI: true, cwd: "/fixture", ui: { setHeader: (factory: Function) => {
+		header = factory({ requestRender() {} }, { fg: (_role: string, text: string) => text });
+	} } });
+	t.mock.timers.tick(200);
+	for (let i = 0; i < 10; i++) await Promise.resolve();
+	try {
+		const text = stripAnsi(header!.render(160).join("\n"));
+		assert.match(text, /PLUGINS:\s+1 package\(s\)/);
+		assert.match(text, /EXTENSIONS:\s+2 active/);
+		assert.match(text, /AGENTS:\s+3 agents/);
+	} finally {
+		header!.dispose();
+		shutdown!();
+	}
+});
+
+test("launcher-injected extension directories do not suppress the startup banner", () => {
+	// Gentle Shell launches `pi -e <package-root-dir>`; a directory path is not a subcommand.
+	assert.equal(isPiCliSubcommandInvocation(["node", "pi", "-e", "/opt/gentle-pi"]), false);
+	assert.equal(isPiCliSubcommandInvocation(["node", "pi", "--no-extensions", "-e", "/a", "-e", "/b/ext.mjs"]), false);
+	assert.equal(isPiCliSubcommandInvocation(["node", "pi"]), false);
+	assert.equal(isPiCliSubcommandInvocation(["node", "pi", "-e", "/opt/gentle-pi", "install"]), false);
+	for (const sub of ["install", "remove", "uninstall", "update", "list", "config", "auth"]) {
+		assert.equal(isPiCliSubcommandInvocation(["node", "pi", sub, "npm:x"]), true, sub);
+	}
+});

package/tests/stats-collector.test.ts

@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { aggregateStats, createStatsLoader, currentSessionStats, parseSessionLines, shiftDay, STATS_RANGE, STATS_SCOPE, weekdayOf, type StatsFilter } from "../lib/stats-collector.ts";
+import { SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+
+// The /gentle:stats collector: a streaming loader over Pi's session files and
+// pure aggregation over the parsed records. Fixtures carry exact numbers so
+// every figure the panel shows is pinned here.
+
+const SESSIONS = fileURLToPath(new URL("./fixtures/stats/sessions", import.meta.url));
+// A second home (the user's regular Pi) holding an OpenAI session and copies of aaa and bbb.
+const USER_SESSIONS = fileURLToPath(new URL("./fixtures/stats/user-pi/sessions", import.meta.url));
+const NOW = Date.parse("2026-10-01T12:00:00.000Z");
+const utcDay = (ms: number) => new Date(ms).toISOString().slice(0, 10);
+const filter = (overrides: Partial<StatsFilter> = {}): StatsFilter => ({ range: STATS_RANGE.ALL, scope: STATS_SCOPE.ALL, cwd: "/work/alpha", now: NOW, dayKey: utcDay, ...overrides });
+
+test("loader reads top-level session files only and tolerates malformed lines", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS]);
+	assert.deepEqual(sessions.map((session) => session.id).sort(), ["aaa", "bbb", "ccc", "ddd"]);
+	const aaa = sessions.find((session) => session.id === "aaa")!;
+	assert.equal(aaa.cwd, "/work/alpha");
+	assert.equal(aaa.messages.length, 2);
+	assert.deepEqual(aaa.messages[0], { timestamp: Date.parse("2026-09-28T10:01:00.000Z"), provider: "claude-bridge", model: "claude-opus-5-5", input: 100, output: 50, cacheRead: 1000, cacheWrite: 200, total: 1350, cost: 0.5 });
+	// Older usage without totalTokens falls back to the sum of its parts.
+	assert.equal(sessions.find((session) => session.id === "ccc")!.messages[0].total, 1000);
+	assert.equal(sessions.some((session) => session.messages.some((message) => message.model === "nested-model")), false);
+});
+
+test("loader returns nothing for a missing or empty sessions root", async () => {
+	const loader = createStatsLoader();
+	assert.deepEqual(await loader.load([join(tmpdir(), "gentle-stats-missing-root")]), []);
+	assert.deepEqual(await loader.load([mkdtempSync(join(tmpdir(), "gentle-stats-empty-"))]), []);
+	assert.deepEqual(await loader.load([]), []);
+});
+
+test("two roots combine into one history: OpenAI usage from the second root counts, duplicate session IDs count once", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS, USER_SESSIONS]);
+	assert.deepEqual(sessions.map((session) => session.id).sort(), ["aaa", "bbb", "ccc", "ddd", "fff"]);
+	const stats = aggregateStats(sessions, filter());
+	assert.deepEqual(stats.totals, { input: 2810, output: 1840, cacheRead: 1000, cacheWrite: 200, total: 5850, cost: 3.85 });
+	assert.deepEqual(stats.models.map(({ model, tokens, messages }) => [model, tokens, messages]), [["gpt-5.3-codex", 3000, 1], ["claude-opus-5-5", 1550, 4], ["gpt-5.5", 1000, 1], ["gpt-6.1-sol", 300, 1]]);
+	assert.deepEqual(stats.days, { "2026-09-01": 1000, "2026-09-20": 3000, "2026-09-28": 1650, "2026-09-29": 30, "2026-09-30": 170 });
+	assert.equal(stats.sessions, 4);
+	const gamma = aggregateStats(sessions, filter({ scope: STATS_SCOPE.PROJECT, cwd: "/work/gamma" }));
+	assert.deepEqual(gamma.models.map((model) => model.model), ["gpt-5.3-codex"]);
+	assert.equal(gamma.totals.total, 3000);
+});
+
+test("a duplicate session keeps the copy with the most usage records, then the latest usage, whatever the root order", async () => {
+	for (const roots of [[SESSIONS, USER_SESSIONS], [USER_SESSIONS, SESSIONS]]) {
+		const sessions = await createStatsLoader().load(roots);
+		// aaa: the active copy has 2 usage records, the user copy 1 → the active copy wins.
+		assert.deepEqual(sessions.find((session) => session.id === "aaa")!.messages.map((message) => message.total), [1350, 300]);
+		// bbb: the user copy has 3 usage records, the active copy 2 → the user copy wins.
+		assert.deepEqual(sessions.find((session) => session.id === "bbb")!.messages.map((message) => message.total), [30, 70, 100]);
+		assert.equal(sessions.filter((session) => session.id === "aaa" || session.id === "bbb").length, 2);
+	}
+	const root = mkdtempSync(join(tmpdir(), "gentle-stats-tie-"));
+	const header = (id: string) => JSON.stringify({ type: "session", version: 3, id, timestamp: "2026-09-01T00:00:00.000Z", cwd: "/t" });
+	const usage = (at: string, total: number) => JSON.stringify({ type: "message", timestamp: at, message: { role: "assistant", model: "m", usage: { output: total } } });
+	const write = (dir: string, name: string, lines: string[]) => { mkdirSync(join(root, dir), { recursive: true }); writeFileSync(join(root, dir, name), `${lines.join("\n")}\n`); };
+	write("a", "1_tie.jsonl", [header("tie"), usage("2026-09-01T00:01:00.000Z", 1)]);
+	write("b", "2_tie.jsonl", [header("tie"), usage("2026-09-01T00:02:00.000Z", 2)]);
+	// Equal record counts fall back to the latest usage timestamp.
+	assert.deepEqual((await createStatsLoader().load([root])).map((session) => session.messages[0].total), [2]);
+	// Headers without an ID are never merged with each other.
+	write("a", "3_noid.jsonl", [JSON.stringify({ type: "session", version: 3, cwd: "/t" }), usage("2026-09-02T00:00:00.000Z", 5)]);
+	write("b", "4_noid.jsonl", [JSON.stringify({ type: "session", version: 3, cwd: "/t" }), usage("2026-09-03T00:00:00.000Z", 7)]);
+	assert.deepEqual((await createStatsLoader().load([root])).map((session) => session.messages[0].total).sort(), [2, 5, 7]);
+});
+
+test("alias roots (trailing slash, dot segments, symlinks) and missing roots never double count", async () => {
+	const link = join(mkdtempSync(join(tmpdir(), "gentle-stats-alias-")), "sessions-link");
+	symlinkSync(SESSIONS, link, "dir");
+	const missing = join(tmpdir(), "gentle-stats-missing-root");
+	const once = aggregateStats(await createStatsLoader().load([SESSIONS]), filter());
+	const aliased = aggregateStats(await createStatsLoader().load([SESSIONS, `${SESSIONS}/`, join(SESSIONS, "..", "sessions"), link, missing]), filter());
+	assert.deepEqual(aliased.totals, once.totals);
+	assert.equal(aliased.sessions, 3);
+});
+
+test("parseSessionLines ignores files without a session header", () => {
+	assert.equal(parseSessionLines(["garbage", "{\"type\":\"message\"}"]), undefined);
+	const parsed = parseSessionLines([
+		"{\"type\":\"session\",\"id\":\"x\",\"timestamp\":\"2026-09-01T00:00:00.000Z\",\"cwd\":\"/x\"}",
+		"{\"type\":\"message\",\"timestamp\":\"2026-09-01T00:01:00.000Z\",\"message\":{\"role\":\"assistant\",\"model\":\"m\",\"usage\":{\"input\":\"bad\",\"output\":3}}}",
+	]);
+	assert.equal(parsed?.messages[0].input, 0);
+	assert.equal(parsed?.messages[0].total, 3);
+	assert.equal(parsed?.messages[0].provider, "unknown");
+});
+
+test("all-time stats across every project match the fixture exactly", async () => {
+	const stats = aggregateStats(await createStatsLoader().load([SESSIONS]), filter());
+	assert.deepEqual(stats.totals, { input: 810, output: 740, cacheRead: 1000, cacheWrite: 200, total: 2750, cost: 2.05 });
+	assert.deepEqual(stats.models.map(({ model, tokens, messages }) => [model, tokens, messages]), [["claude-opus-5-5", 1450, 3], ["gpt-5.5", 1000, 1], ["gpt-6.1-sol", 300, 1]]);
+	assert.equal(stats.models[0].cost.toFixed(2), "0.80");
+	assert.equal(stats.models[0].share, 1450 / 2750);
+	assert.deepEqual(stats.days, { "2026-09-01": 1000, "2026-09-28": 1650, "2026-09-29": 30, "2026-09-30": 70 });
+	assert.equal(stats.sessions, 3);
+	assert.equal(stats.activeDays, 4);
+	assert.equal(stats.daysInRange, 31);
+	assert.equal(stats.firstDay, "2026-09-01");
+	assert.equal(stats.today, "2026-10-01");
+	assert.deepEqual(stats.mostActiveDay, { day: "2026-09-28", tokens: 1650 });
+	assert.deepEqual(stats.longestSession, { id: "bbb", durationMs: 2 * 60 * 60 * 1000 });
+	assert.equal(stats.longestStreak, 3);
+	assert.equal(stats.currentStreak, 3);
+});
+
+test("range filters count only messages inside the selected local days", async () => {
+	const sessions = await createStatsLoader().load([SESSIONS]);
+	const week = aggregateStats(sessions, filter({ range: STATS_RANGE.WEEK }));
+	assert.equal(week.totals.total, 1750);
+	assert.equal(week.totals.cost.toFixed(2), "1.05");
+	assert.equal(week.sessions, 2);
+	assert.equal(week.activeDays, 3);
+	assert.equal(week.daysInRange, 7);
+	assert.equal(week.firstDay, "2026-09-25");
+	// 2026-09-01 sits one day before the 30-day window that ends today.
+	const month = aggregateStats(sessions, filter({ range: STATS_RANGE.MONTH }));
+	assert.equal(month.totals.total, 1750);
+	assert.equal(month.daysInRange, 30);
+	assert.equal(month.firstDay, "2026-09-02");
+});
+
+test("project scope keeps only sessions started in the current cwd", async () => {
+	const stats = aggregateStats(await createStatsLoader().load([SESSIONS]), filter({ scope: STATS_SCOPE.PROJECT, cwd: "/work/beta" }));
+	assert.equal(stats.totals.total, 1000);
+	assert.equal(stats.sessions, 1);
+	assert.equal(stats.longestStreak, 1);
+	assert.equal(stats.currentStreak, 0);
+	assert.deepEqual(stats.models.map((model) => model.model), ["gpt-5.5"]);
+});
+
+test("current streak survives an idle today but breaks after a missed day", () => {
+	const session = (id: string, ...days: string[]) => ({
+		id, cwd: "/x", startedAt: Date.parse(`${days[0]}T10:00:00.000Z`),
+		messages: days.map((day) => ({ timestamp: Date.parse(`${day}T10:00:00.000Z`), provider: "p", model: "m", input: 1, output: 0, cacheRead: 0, cacheWrite: 0, total: 1, cost: 0 })),
+	});
+	const active = aggregateStats([session("a", "2026-09-29", "2026-09-30", "2026-10-01")], filter());
+	assert.equal(active.currentStreak, 3);
+	const broken = aggregateStats([session("a", "2026-09-28", "2026-09-29")], filter());
+	assert.equal(broken.currentStreak, 0);
+	assert.equal(broken.longestStreak, 2);
+});
+
+test("empty input aggregates to zeroes without throwing", () => {
+	const stats = aggregateStats([], filter());
+	assert.deepEqual(stats.totals, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 });
+	assert.deepEqual(stats.models, []);
+	assert.equal(stats.sessions, 0);
+	assert.equal(stats.activeDays, 0);
+	assert.equal(stats.daysInRange, 1);
+	assert.equal(stats.mostActiveDay, undefined);
+	assert.equal(stats.longestSession, undefined);
+	assert.equal(stats.longestStreak, 0);
+	assert.equal(stats.currentStreak, 0);
+});
+
+test("day keys shift across month boundaries and report their weekday", () => {
+	assert.equal(shiftDay("2026-10-01", -1), "2026-09-30");
+	assert.equal(shiftDay("2026-12-31", 1), "2027-01-01");
+	assert.equal(weekdayOf("2026-10-01"), 4); // Thursday
+});
+
+test("loader reuses unchanged files from its cache", async () => {
+	const loader = createStatsLoader();
+	const first = await loader.load([SESSIONS]);
+	const second = await loader.load([SESSIONS]);
+	assert.equal(first.find((session) => session.id === "aaa"), second.find((session) => session.id === "aaa"));
+});
+
+test("currentSessionStats summarizes the live session including captured line changes", () => {
+	const entries = [
+		{ type: "model_change", timestamp: "2026-10-01T11:00:00.000Z", provider: "claude-bridge", modelId: "claude-opus-5-5" },
+		{ type: "message", timestamp: "2026-10-01T11:01:00.000Z", message: { role: "assistant", provider: "claude-bridge", model: "claude-opus-5-5", usage: { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, totalTokens: 135, cost: { total: 0.125 } } } },
+		{ type: "message", timestamp: "2026-10-01T11:02:00.000Z", message: { role: "user", content: "x" } },
+		{ type: "custom", customType: SESSION_CHANGE_ENTRY, timestamp: "2026-10-01T11:03:00.000Z", data: { sessionId: "live", evidence: { id: "e1", root: "/repo", path: "a.txt", before: { kind: "text", text: "a\nb\n" }, after: { kind: "text", text: "a\nc\nd\n" } } } },
+	];
+	const stats = currentSessionStats(entries, { sessionId: "live", now: Date.parse("2026-10-01T11:30:00.000Z") });
+	assert.deepEqual(stats.totals, { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, total: 135, cost: 0.125 });
+	assert.equal(stats.messages, 1);
+	assert.equal(stats.model, "claude-opus-5-5");
+	assert.equal(stats.durationMs, 30 * 60 * 1000);
+	assert.deepEqual(stats.lines, { added: 2, removed: 1 });
+	const empty = currentSessionStats([], { sessionId: "none", now: NOW });
+	assert.equal(empty.durationMs, 0);
+	assert.equal(empty.lines, undefined);
+	assert.equal(empty.model, undefined);
+});