@selesai/code 0.13.11 → 0.13.13

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

@@ -1,276 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,327 +0,0 @@
-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([]);
-	});
-});