@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-zentui/test/telemetry-lifecycle-integration.test.ts

@@ -0,0 +1,276 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const capabilities = vi.hoisted(() => ({
+	subscription: undefined as boolean | undefined,
+	autoCompaction: undefined as boolean | undefined,
+	throwSubscription: false,
+	throwAutoCompaction: false,
+	settingsCreate: vi.fn(),
+}));
+
+vi.mock("@earendil-works/pi-coding-agent", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("@earendil-works/pi-coding-agent")>();
+	return {
+		...actual,
+		SettingsManager: {
+			create(...args: unknown[]) {
+				capabilities.settingsCreate(...args);
+				if (capabilities.throwAutoCompaction) throw new Error("unsupported settings");
+				return {
+					drainErrors: () => [],
+					getCompactionEnabled: () => capabilities.autoCompaction,
+				};
+			},
+		},
+	};
+});
+
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		ensureConfigExists: () => {},
+		loadConfig: () => {
+			const footer = actual.defaultConfig.components.footer;
+			return {
+				...actual.defaultConfig,
+				projectRefreshIntervalMs: 0,
+				components: {
+					...actual.defaultConfig.components,
+					editor: { ...actual.defaultConfig.components.editor, enabled: false },
+					footer: {
+						...footer,
+						enabled: true,
+						style: "starship",
+						styles: {
+							starship: {
+								...footer.styles.starship,
+								segments: { ...footer.styles.starship.segments, modelInfo: true },
+							},
+						},
+					},
+				},
+			};
+		},
+	};
+});
+
+vi.mock("../extensions/zentui/git", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/git")>();
+	return {
+		...actual,
+		readGitStatus: async () => ({ kind: "ok" as const, status: actual.emptyGitStatus() }),
+	};
+});
+vi.mock("../extensions/zentui/runtime", () => ({
+	readRuntimeInfo: async () => ({ kind: "ok" as const, runtime: undefined }),
+}));
+vi.mock("../extensions/zentui/package-version", () => ({
+	readPackageVersionResult: async () => ({ kind: "ok" as const, result: null }),
+}));
+
+import zentui from "../extensions/zentui/index";
+
+type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;
+type Footer = { render(width: number): string[]; dispose?: () => void };
+type FooterFactory = (...args: unknown[]) => Footer;
+
+function makeTheme(): Theme {
+	return {
+		fg: (_color: string, text: string) => text,
+		bold: (text: string) => text,
+		italic: (text: string) => text,
+		underline: (text: string) => text,
+		strikethrough: (text: string) => text,
+		getThinkingBorderColor: () => (text: string) => text,
+	} as unknown as Theme;
+}
+
+function usageEntry(
+	id: string,
+	options: { input: number; output: number; read?: number; write?: number },
+) {
+	return {
+		type: "message",
+		id,
+		message: {
+			role: "assistant",
+			usage: {
+				input: options.input,
+				output: options.output,
+				cacheRead: options.read ?? 0,
+				cacheWrite: options.write ?? 0,
+				cost: { total: 0 },
+			},
+		},
+	};
+}
+
+function createHarness(name: string) {
+	let footerFactory: FooterFactory | undefined;
+	const entries = [usageEntry(`${name}-initial`, { input: 10, output: 2 })];
+	const state = { model: { id: `${name}-model`, provider: "test", contextWindow: 10_000 } };
+	const theme = makeTheme();
+	const ctx = {
+		hasUI: true,
+		mode: "tui",
+		cwd: `/tmp/${name}`,
+		get model() {
+			return state.model;
+		},
+		modelRegistry: {
+			isUsingOAuth() {
+				if (capabilities.throwSubscription) throw new Error("unsupported OAuth lookup");
+				return capabilities.subscription;
+			},
+		},
+		isProjectTrusted: () => true,
+		getContextUsage: () => ({ tokens: 1_000, contextWindow: 10_000, percent: 10 }),
+		sessionManager: {
+			getBranch: () => entries,
+			getEntries: () => entries,
+			getSessionName: () => undefined,
+		},
+		ui: {
+			theme,
+			setFooter(factory: FooterFactory | undefined) {
+				footerFactory = factory;
+			},
+			setEditorComponent() {},
+			getEditorComponent: () => undefined,
+		},
+	};
+	return {
+		ctx,
+		entries,
+		state,
+		createFooter() {
+			if (!footerFactory) throw new Error("footer was not installed");
+			return footerFactory({ requestRender() {} }, theme, {
+				onBranchChange: () => () => {},
+				getExtensionStatuses: () => new Map<string, string>(),
+			});
+		},
+	};
+}
+
+function loadExtension() {
+	const handlers = new Map<string, Handler[]>();
+	zentui({
+		on(name: string, handler: Handler) {
+			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+		},
+		registerCommand() {},
+		getThinkingLevel: () => "off",
+	} as never);
+	return handlers;
+}
+
+async function emit(handlers: Map<string, Handler[]>, name: string, ctx: unknown, event = {}) {
+	for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+}
+
+function rendered(footer: Footer): string {
+	return footer.render(160).join("\n");
+}
+
+beforeEach(() => {
+	capabilities.subscription = undefined;
+	capabilities.autoCompaction = undefined;
+	capabilities.throwSubscription = false;
+	capabilities.throwAutoCompaction = false;
+	capabilities.settingsCreate.mockClear();
+});
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("telemetry lifecycle integration", () => {
+	it("initializes, refreshes, clears unsupported values, and reconciles at agent_end", async () => {
+		const handlers = loadExtension();
+		const harness = createHarness("telemetry-events");
+		capabilities.subscription = true;
+		capabilities.autoCompaction = false;
+
+		await emit(handlers, "session_start", harness.ctx);
+		const footer = harness.createFooter();
+		expect(rendered(footer)).toContain("telemetry-events-model Test");
+		expect(rendered(footer)).toContain("$0.000 (sub)");
+		expect(rendered(footer)).not.toContain("(auto)");
+
+		harness.state.model = {
+			...harness.state.model,
+			id: "selected-model",
+			provider: "changed-provider",
+		};
+		capabilities.subscription = false;
+		capabilities.autoCompaction = false;
+		await emit(handlers, "model_select", harness.ctx);
+		expect(rendered(footer)).toContain("selected-model Changed Provider");
+		expect(rendered(footer)).not.toContain("telemetry-events-model Test");
+		expect(rendered(footer)).not.toContain("(sub)");
+
+		capabilities.subscription = false;
+		capabilities.autoCompaction = true;
+		await emit(handlers, "tool_execution_end", harness.ctx);
+		expect(rendered(footer)).toContain("10.0%/10k (auto)");
+
+		capabilities.subscription = true;
+		capabilities.autoCompaction = true;
+		await emit(handlers, "session_info_changed", harness.ctx);
+		expect(rendered(footer)).toContain("$0.000 (sub)");
+		expect(rendered(footer)).toContain("10.0%/10k (auto)");
+
+		capabilities.throwSubscription = true;
+		capabilities.throwAutoCompaction = true;
+		await expect(emit(handlers, "session_info_changed", harness.ctx)).resolves.toBeUndefined();
+		expect(rendered(footer)).not.toMatch(/\(sub\)|\(auto\)/);
+
+		capabilities.throwSubscription = false;
+		capabilities.throwAutoCompaction = false;
+		capabilities.subscription = true;
+		capabilities.autoCompaction = true;
+		await emit(handlers, "message_end", harness.ctx, {
+			message: { role: "assistant", usage: { input: 5, output: 3 } },
+		});
+		harness.entries.push(
+			usageEntry("persisted-final", { input: 5, output: 3, read: 1_200, write: 300 }),
+		);
+		await emit(handlers, "agent_end", harness.ctx);
+		const final = rendered(footer);
+		expect(final).toContain("↑15 ↓5");
+		expect(final).toContain("R1.2k W300");
+		expect(final).toContain("$0.000 (sub)");
+		expect(final).toContain("10.0%/10k (auto)");
+
+		footer.dispose?.();
+		await emit(handlers, "session_shutdown", harness.ctx);
+	});
+
+	it("does not leak telemetry across shutdown and replacement session start", async () => {
+		const handlers = loadExtension();
+		const first = createHarness("telemetry-first");
+		capabilities.subscription = true;
+		capabilities.autoCompaction = true;
+		await emit(handlers, "session_start", first.ctx);
+		const firstFooter = first.createFooter();
+		expect(rendered(firstFooter)).toMatch(/\(sub\).*\(auto\)|\(auto\).*\(sub\)/);
+		await emit(handlers, "session_shutdown", first.ctx);
+		expect(() => first.createFooter()).toThrow("footer was not installed");
+
+		const replacement = createHarness("telemetry-replacement");
+		capabilities.subscription = undefined;
+		capabilities.autoCompaction = undefined;
+		await emit(handlers, "session_start", replacement.ctx);
+		const replacementFooter = replacement.createFooter();
+		expect(rendered(replacementFooter)).not.toMatch(/\(sub\)|\(auto\)|R1\.2k|W300/);
+		expect(capabilities.settingsCreate).toHaveBeenLastCalledWith(
+			"/tmp/telemetry-replacement",
+			undefined,
+			{ projectTrusted: true },
+		);
+
+		replacementFooter.dispose?.();
+		await emit(handlers, "session_shutdown", replacement.ctx);
+	});
+});

package/dist/extensions/pi-zentui/test/telemetry.test.ts

@@ -0,0 +1,105 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { resolveFooterTelemetry } from "../extensions/zentui/telemetry";
+
+function makeContext(overrides: Record<string, unknown> = {}) {
+	return {
+		cwd: "/tmp/project",
+		model: { id: "model", provider: "anthropic" },
+		modelRegistry: { isUsingOAuth: () => false },
+		isProjectTrusted: () => true,
+		...overrides,
+	} as unknown as ExtensionContext;
+}
+
+function settingsCapability(options: {
+	enabled?: unknown;
+	errors?: unknown[];
+	throwCreate?: boolean;
+}) {
+	const create = vi.fn(() => {
+		if (options.throwCreate) throw new Error("unsupported");
+		return {
+			drainErrors: () => options.errors ?? [],
+			getCompactionEnabled: () => options.enabled,
+		};
+	});
+	return { create };
+}
+
+afterEach(() => vi.restoreAllMocks());
+
+describe("resolveFooterTelemetry", () => {
+	it("uses the public OAuth and settings capabilities", () => {
+		const settingsManager = settingsCapability({ enabled: true });
+		const modelRegistry = { isUsingOAuth: vi.fn(() => true) };
+		const ctx = makeContext({ modelRegistry, isProjectTrusted: () => false });
+
+		expect(resolveFooterTelemetry(ctx, { settingsManager })).toEqual({
+			subscription: true,
+			autoCompaction: true,
+		});
+		expect(modelRegistry.isUsingOAuth).toHaveBeenCalledWith(ctx.model);
+		expect(settingsManager.create).toHaveBeenCalledWith("/tmp/project", undefined, {
+			projectTrusted: false,
+		});
+	});
+
+	it("recognizes Kimi subscription mode without an OAuth lookup", () => {
+		const isUsingOAuth = vi.fn(() => false);
+		const ctx = makeContext({
+			model: { id: "kimi", provider: "kimi-coding" },
+			modelRegistry: { isUsingOAuth },
+		});
+
+		expect(
+			resolveFooterTelemetry(ctx, { settingsManager: settingsCapability({ enabled: false }) }),
+		).toMatchObject({ subscription: true, autoCompaction: false });
+		expect(isUsingOAuth).not.toHaveBeenCalled();
+	});
+
+	it("returns explicit false values when supported telemetry is disabled", () => {
+		expect(
+			resolveFooterTelemetry(makeContext(), {
+				settingsManager: settingsCapability({ enabled: false }),
+			}),
+		).toEqual({ subscription: false, autoCompaction: false });
+	});
+
+	it.each([
+		[
+			"absent capabilities",
+			makeContext({ modelRegistry: {}, isProjectTrusted: undefined }),
+			{ settingsManager: {} },
+			{ subscription: undefined, autoCompaction: undefined },
+		],
+		[
+			"throwing capabilities",
+			makeContext({
+				modelRegistry: {
+					isUsingOAuth: () => {
+						throw new Error("nope");
+					},
+				},
+			}),
+			{ settingsManager: settingsCapability({ throwCreate: true }) },
+			{ subscription: undefined, autoCompaction: undefined },
+		],
+		[
+			"settings load errors",
+			makeContext(),
+			{ settingsManager: settingsCapability({ enabled: true, errors: [new Error("bad json")] }) },
+			{ subscription: false, autoCompaction: undefined },
+		],
+	] as const)("omits unsupported telemetry for %s", (_name, ctx, capabilities, expected) => {
+		expect(resolveFooterTelemetry(ctx, capabilities)).toEqual(expected);
+	});
+
+	it("omits subscription without a model", () => {
+		expect(
+			resolveFooterTelemetry(makeContext({ model: undefined }), {
+				settingsManager: settingsCapability({ enabled: false }),
+			}),
+		).toEqual({ subscription: undefined, autoCompaction: false });
+	});
+});

package/dist/extensions/pi-zentui/test/turn-summary-lifecycle.integration.test.ts

@@ -0,0 +1,327 @@
+import { stripVTControlCharacters } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Text } from "@earendil-works/pi-tui";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TURN_SUMMARY_ENTRY_TYPE } from "../extensions/zentui/interaction-summary";
+
+const stripTerminalSequences = stripVTControlCharacters;
+
+const runtime = vi.hoisted(() => ({
+	enabled: true,
+	turnSummary: true,
+	tokens: true,
+	thought: true,
+}));
+
+vi.mock("../extensions/zentui/config", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../extensions/zentui/config")>();
+	return {
+		...actual,
+		ensureConfigExists() {},
+		loadConfig: () => {
+			const config = structuredClone(actual.defaultConfig);
+			config.projectRefreshIntervalMs = 0;
+			config.components.editor.enabled = false;
+			config.components.userMessages.enabled = false;
+			config.components.selectorBorders.enabled = false;
+			config.components.footer.style = "native";
+			config.components.workingLine.enabled = runtime.enabled;
+			config.components.workingLine.turnSummary = runtime.turnSummary;
+			config.components.workingLine.segments.tokens = runtime.tokens;
+			config.components.workingLine.segments.thought = runtime.thought;
+			config.components.workingLine.messages = { custom: true, values: ["Stable"] };
+			return config;
+		},
+	};
+});
+
+import zentui from "../extensions/zentui/index";
+
+type Handler = (event: unknown, ctx: unknown) => unknown | Promise<unknown>;
+
+function assistant(input: number, output: number, timestamp: number) {
+	return {
+		role: "assistant",
+		usage: { input, output },
+		content: [],
+		api: "test",
+		provider: "provider",
+		model: "model",
+		stopReason: "stop",
+		timestamp,
+	};
+}
+
+function harness(options: { renderer?: boolean; appendError?: boolean } = {}) {
+	const handlers = new Map<string, Handler[]>();
+	const appended: Array<[string, unknown]> = [];
+	const appendEntry = vi.fn((type: string, data: unknown) => {
+		if (options.appendError) throw new Error("append failed");
+		appended.push([type, data]);
+	});
+	const renderers = new Map<string, unknown>();
+	const workingIndicators: Array<{ frames?: string[] }> = [];
+	const sendMessage = vi.fn();
+	zentui({
+		on(name: string, handler: Handler) {
+			handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+		},
+		registerCommand() {},
+		...(options.renderer === false
+			? {}
+			: {
+					registerEntryRenderer(type: string, renderer: unknown) {
+						renderers.set(type, renderer);
+					},
+				}),
+		appendEntry,
+		sendMessage,
+		getThinkingLevel: () => "off",
+	} as never);
+	let idle = true;
+	const ctx = {
+		hasUI: true,
+		mode: "tui",
+		cwd: process.cwd(),
+		model: undefined,
+		isIdle: () => idle,
+		getContextUsage: () => null,
+		sessionManager: { getBranch: () => [], getSessionName: () => undefined },
+		ui: {
+			theme: {
+				fg: (_color: string, text: string) => text,
+				bold: (text: string) => text,
+			} as Theme,
+			getEditorComponent: () => undefined,
+			setWorkingMessage() {},
+			setWorkingIndicator(indicator?: { frames?: string[] }) {
+				if (indicator) workingIndicators.push(indicator);
+			},
+		},
+	};
+	const emit = async (name: string, event: unknown = {}) => {
+		for (const handler of handlers.get(name) ?? []) await handler(event, ctx);
+	};
+	return {
+		appended,
+		appendEntry,
+		renderers,
+		workingIndicators,
+		sendMessage,
+		ctx,
+		emit,
+		setIdle: (value: boolean) => (idle = value),
+	};
+}
+
+beforeEach(() => {
+	runtime.enabled = true;
+	runtime.turnSummary = true;
+	runtime.tokens = true;
+	runtime.thought = true;
+	vi.useRealTimers();
+});
+
+describe("turn summary lifecycle integration", () => {
+	it("appends exactly once at full settlement, never at agent_end, using only appendEntry", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(1_000);
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("turn_start");
+		await current.emit("message_end", { message: assistant(1000, 10, 1) });
+		await current.emit("agent_end");
+		expect(current.appended).toEqual([]);
+		vi.setSystemTime(43_000);
+		await current.emit("agent_settled");
+		expect(current.appended).toEqual([
+			[
+				TURN_SUMMARY_ENTRY_TYPE,
+				{
+					version: 3,
+					durationMs: 42_000,
+					thoughtDurationMs: 0,
+					input: 1000,
+					output: 10,
+					stylePrefix: "\x1b[1;36m",
+				},
+			],
+		]);
+		await current.emit("agent_settled");
+		expect(current.appended).toHaveLength(1);
+		expect(current.sendMessage).not.toHaveBeenCalled();
+		expect(current.renderers.has(TURN_SUMMARY_ENTRY_TYPE)).toBe(true);
+	});
+
+	it("persists thought in v3 even when the live Thinking segment is disabled", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(1_000);
+		runtime.thought = false;
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("turn_start");
+		const message = assistant(7_100, 779, 1);
+		await current.emit("message_update", {
+			message,
+			assistantMessageEvent: { type: "thinking_start", contentIndex: 0, partial: message },
+		});
+		const activeThoughtFrames = current.workingIndicators.at(-1)?.frames ?? [];
+		expect(activeThoughtFrames.length).toBeGreaterThan(0);
+		for (const frame of activeThoughtFrames) {
+			const liveText = stripTerminalSequences(frame);
+			expect(liveText).not.toMatch(/(?:^| · )thinking \d+s(?: · |$)/);
+			expect(liveText).not.toMatch(/(?:^| · )thought for \d+s(?: · |$)/);
+		}
+		vi.setSystemTime(11_999);
+		await current.emit("message_update", {
+			message,
+			assistantMessageEvent: {
+				type: "thinking_end",
+				contentIndex: 0,
+				content: "done",
+				partial: message,
+			},
+		});
+		await current.emit("message_end", { message });
+		await current.emit("agent_end");
+		vi.setSystemTime(57_999);
+		await current.emit("agent_settled");
+		expect(current.appended[0]?.[1]).toEqual(
+			expect.objectContaining({ version: 3, thoughtDurationMs: 10_999, input: 7_100, output: 779 }),
+		);
+		const renderer = current.renderers.get(TURN_SUMMARY_ENTRY_TYPE) as
+			| ((entry: { data: unknown }, options: unknown, theme: Theme) => Text | undefined)
+			| undefined;
+		const rendered = renderer?.({ data: current.appended[0]?.[1] }, {}, current.ctx.ui.theme)
+			?.render(100)
+			.join("\n");
+		expect(stripTerminalSequences(rendered ?? "")).toContain("thought for 10s");
+	});
+
+	it.each([
+		[false, true],
+		[true, false],
+	] as const)(
+		"gates append by Working-line enabled=%s and summary=%s",
+		async (enabled, summary) => {
+			runtime.enabled = enabled;
+			runtime.turnSummary = summary;
+			const current = harness();
+			await current.emit("session_start");
+			await current.emit("agent_start");
+			await current.emit("agent_end");
+			await current.emit("agent_settled");
+			expect(current.appended).toEqual([]);
+		},
+	);
+
+	it("initializes and settles without registerEntryRenderer", async () => {
+		const current = harness({ renderer: false });
+		await expect(current.emit("session_start")).resolves.toBeUndefined();
+		await current.emit("agent_start");
+		await current.emit("agent_end");
+		await expect(current.emit("agent_settled")).resolves.toBeUndefined();
+		expect(current.appended).toHaveLength(1);
+	});
+
+	it("contains append failures after atomic settlement and handles the next interaction", async () => {
+		const current = harness({ appendError: true });
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("agent_end");
+		await expect(current.emit("agent_settled")).resolves.toBeUndefined();
+		expect(current.appendEntry).toHaveBeenCalledTimes(1);
+		await current.emit("agent_settled");
+		expect(current.appendEntry).toHaveBeenCalledTimes(1);
+
+		await current.emit("agent_start");
+		await current.emit("agent_end");
+		await current.emit("agent_settled");
+		expect(current.appendEntry).toHaveBeenCalledTimes(2);
+	});
+
+	it("partitions a completed run from concurrent live usage on non-idle settlement", async () => {
+		vi.useFakeTimers();
+		vi.setSystemTime(1_000);
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("turn_start");
+		await current.emit("message_end", { message: assistant(10, 1, 1) });
+		await current.emit("agent_end");
+
+		vi.setSystemTime(5_000);
+		await current.emit("agent_start");
+		await current.emit("turn_start");
+		await current.emit("message_update", { message: assistant(7, 2, 2) });
+		current.setIdle(false);
+		vi.setSystemTime(6_000);
+		await current.emit("agent_settled");
+		expect(current.appended).toEqual([
+			[
+				TURN_SUMMARY_ENTRY_TYPE,
+				expect.objectContaining({
+					version: 3,
+					durationMs: 5_000,
+					thoughtDurationMs: 0,
+					input: 10,
+					output: 1,
+				}),
+			],
+		]);
+
+		await current.emit("message_end", { message: assistant(9, 3, 2) });
+		await current.emit("agent_end");
+		current.setIdle(true);
+		vi.setSystemTime(9_000);
+		await current.emit("agent_settled");
+		expect(current.appended[1]).toEqual([
+			TURN_SUMMARY_ENTRY_TYPE,
+			expect.objectContaining({
+				version: 3,
+				durationMs: 4_000,
+				thoughtDurationMs: 0,
+				input: 9,
+				output: 3,
+			}),
+		]);
+		await current.emit("agent_settled");
+		expect(current.appended).toHaveLength(2);
+	});
+
+	it("commits and settles zero-only final usage exactly once", async () => {
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("turn_start");
+		await current.emit("message_update", { message: assistant(0, 0, 1) });
+		await current.emit("message_update", { message: assistant(0, 0, 1) });
+		await current.emit("message_end", { message: assistant(0, 0, 1) });
+		await current.emit("agent_end");
+		await current.emit("agent_settled");
+		await current.emit("agent_settled");
+		expect(current.appended).toEqual([
+			[TURN_SUMMARY_ENTRY_TYPE, expect.objectContaining({ input: 0, output: 0 })],
+		]);
+	});
+
+	it("includes zero totals when live Tokens is disabled", async () => {
+		runtime.tokens = false;
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("agent_end");
+		await current.emit("agent_settled");
+		expect(current.appended[0]?.[1]).toMatchObject({ input: 0, output: 0 });
+	});
+
+	it("does not synthesize a summary on shutdown", async () => {
+		const current = harness();
+		await current.emit("session_start");
+		await current.emit("agent_start");
+		await current.emit("session_shutdown");
+		expect(current.appended).toEqual([]);
+	});
+});