@zenodinh/pi-render 0.1.0 → 0.1.2

package/index.ts

@@ -275,5 +275,10 @@ export default async function piRender(pi: ExtensionApi, deps: BootDeps = {}): P
 	await settle("commands", log, () => installCanvasCommand(pi, registry));
 
 	// Collapse-first reading model (owner decision): every tool row starts on one line.
-	pi.setToolsExpanded(false);
+	// The host exposes this on the per-event UI context (ctx.ui), not on the pi API — only
+	// interactive mode implements it (the runner's non-UI fallback is a no-op stub), so the
+	// call rides session_start: real in TUI, harmless in text/rpc.
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui?.setToolsExpanded?.(false);
+	});
 }

package/package.json

@@ -10,7 +10,11 @@
 	"files": [
 		"index.ts",
 		"src",
-		"themes"
+		"themes",
+		"!src/**/*.test.ts",
+		"!src/**/__snapshots__",
+		"!test",
+		"!themes/*.test.ts"
 	],
 	"scripts": {
 		"check": "tsc --noEmit",
@@ -63,5 +67,5 @@
 		"typescript": "^7.0.2",
 		"vitest": "^5.0.3"
 	},
-	"version": "0.1.0"
+	"version": "0.1.2"
 }

package/src/core/types/host.ts

@@ -155,6 +155,15 @@ export interface ExtensionApi {
 		name: string,
 		options: { description?: string; handler: (args: string, ctx: CommandContext) => Promise<void> },
 	): void;
-	/** Collapses every tool row to one line at boot. Required; the render-only default is false. */
-	setToolsExpanded(expanded: boolean): void;
+	/** Subscribes to a host event, e.g. "session_start". Required; the per-event ctx carries ui. */
+	on(event: string, handler: (event: unknown, ctx: EventContext) => void): void;
+}
+
+/** The context a host event handler receives. Structural host shape. */
+export interface EventContext {
+	/** The host's UI surface for this event — present in interactive mode, a no-op stub otherwise. Optional. */
+	ui?: {
+		/** Collapses (false) / expands (true) every tool row. The collapse-first default rides this. Optional. */
+		setToolsExpanded?(expanded: boolean): void;
+	};
 }

package/src/commands/canvas.test.ts

@@ -1,150 +0,0 @@
-/**
- * canvas through its seam — installCommands(pi, deps) on the recording host API, its handler driven
- * with a host-shaped context and the REAL registry (the command's only channel to the package).
- *
- * invented: the settings documents and the content.artifacts descriptor below are hand-built to the
- *   SA §3 literal (version + modules map) keyed on SA §6's artifacts module — T-25/T-26 own the real
- *   descriptor and T-07 the on-disk file, so there is no recorded payload to reuse; the documents are
- *   what drives the enabled/disabled state this command reports.
- * invented: the context double and the view recorder stand in for the host and for the browser T-28
- *   injects — the command's own seam is exactly these two collaborators.
- */
-
-import { readFileSync } from "node:fs";
-import { describe, expect, test } from "vitest";
-import type { RecordedApiCall, RecordedCommandRegistration } from "../../test/fakes/index.ts";
-import { recordingExtensionApi } from "../../test/fakes/index.ts";
-import { createRegistry } from "../core/registry.ts";
-import type { CommandContext, Logger, ModuleDescriptor, SettingsDoc } from "../core/types.ts";
-import { installCommands } from "./canvas.ts";
-
-const ARTIFACTS: ModuleDescriptor = { key: "content.artifacts", name: "Artifacts", defaultEnabled: true, settings: [] };
-const ENABLED: SettingsDoc = { version: 1, modules: { "content.artifacts": { enabled: true } } };
-const DISABLED: SettingsDoc = { version: 1, modules: { "content.artifacts": { enabled: false } } };
-const NON_TUI = ["rpc", "json", "print"] as const;
-
-/** The registry's own diagnostics are T-09's concern, not this seam's. */
-const SILENT: Logger = { logLine: () => {}, logOnce: () => {}, drain: () => [] };
-
-/** Every `from "<specifier>"` in a source file. */
-const IMPORT_SPECIFIER = /from\s+"([^"]+)"/g;
-
-interface Harness {
-	/** Every registration the install made, in order. */
-	readonly calls: readonly RecordedApiCall[];
-	/** The command registrations, in order. */
-	readonly commands: readonly RecordedCommandRegistration[];
-	/** Every ctx the injected view opened with. */
-	readonly opened: CommandContext[];
-	/** Every document the registry saved — a /canvas run must leave this empty (SA §7). */
-	readonly saved: SettingsDoc[];
-}
-
-function harness(doc: SettingsDoc): Harness {
-	const pi = recordingExtensionApi();
-	const opened: CommandContext[] = [];
-	const saved: SettingsDoc[] = [];
-	const registry = createRegistry({ load: () => structuredClone(doc), save: (next) => void saved.push(next) }, SILENT);
-	registry.defineModule(ARTIFACTS);
-	installCommands(pi, {
-		registry,
-		canvasView: async (ctx) => {
-			// One macrotask, like the real panel open: an implementation that drops the await leaves
-			// `opened` empty when the test asserts (ASY-1), so the assertion pins the await too.
-			await new Promise((resolve) => setImmediate(resolve));
-			opened.push(ctx);
-		},
-	});
-	return { calls: pi.calls, commands: pi.commands, opened, saved };
-}
-
-interface Run {
-	/** The context the host handed the handler. */
-	readonly ctx: CommandContext;
-	/** Every notify message the handler produced, in order. */
-	readonly notices: readonly string[];
-}
-
-/** Enters where the host enters: the registered handler, with a host-shaped context, awaited. */
-async function runCanvas(h: Harness, mode: CommandContext["mode"]): Promise<Run> {
-	const handler = h.commands[0]?.options.handler;
-	if (handler === undefined) throw new Error("no canvas command registered");
-	const notices: string[] = [];
-	const ctx: CommandContext = {
-		mode,
-		ui: {
-			notify: (message) => {
-				notices.push(message);
-			},
-		},
-	};
-	await handler("", ctx);
-	return { ctx, notices };
-}
-
-describe("canvas command", () => {
-	// spec: installCommands(pi, deps) -> exactly one registerCommand call, named "canvas", handler callable.
-	// fails_when: zero, duplicate, or extra commands (a second site, a renamed or missing command).
-	test("AC-1 installCommands registers exactly one command named canvas", () => {
-		const h = harness(ENABLED);
-
-		expect(h.commands.map((command) => command.name)).toEqual(["canvas"]);
-		expect(typeof h.commands[0]?.options.handler).toBe("function");
-		// The command lane touches its own seam only — no setToolsExpanded, no resolver, no transformer.
-		expect(h.calls.map((call) => call.method)).toEqual(["registerCommand"]);
-	});
-
-	// spec: /canvas in a non-TUI host (rpc/json/print) -> one notify carrying the status summary; the
-	//   view never opens and nothing throws.
-	// fails_when: a non-TUI host crashes, goes silent, or opens a view it cannot draw.
-	test("AC-2 a non-TUI host gets a notify summary and never the view", async () => {
-		for (const mode of NON_TUI) {
-			const h = harness(ENABLED);
-
-			const run = await runCanvas(h, mode);
-
-			expect(run.notices).toEqual([
-				`canvas: content.artifacts is enabled — the artifact browser needs a TUI host (mode: ${mode})`,
-			]);
-			expect(h.opened).toEqual([]);
-		}
-	});
-
-	// spec: the module's imports -> exactly ["../core/types.ts"]; status comes from the registry, not a lane.
-	// fails_when: the command reaches into a renderer lane for state instead of the registry (SA §1 rule 3).
-	test("AC-3 the command reaches the package only through core", () => {
-		const source = readFileSync(new URL("./canvas.ts", import.meta.url), "utf8");
-
-		const specifiers = [...source.matchAll(IMPORT_SPECIFIER)].map((match) => match[1] ?? "");
-
-		expect(specifiers).toEqual(["../core/types.ts"]);
-	});
-
-	// spec: content.artifacts disabled in the registry + a TUI host -> one notify reporting the disabled
-	//   state, the view never opens, the registry is never written.
-	// fails_when: a disabled module's command acts anyway, or the report stays silent.
-	test("AC-4 a disabled content.artifacts reports instead of opening the view", async () => {
-		const h = harness(DISABLED);
-
-		const run = await runCanvas(h, "tui");
-
-		expect(run.notices).toEqual(["canvas: content.artifacts is disabled — enable it to open the artifact browser"]);
-		expect(h.opened).toEqual([]);
-		expect(h.saved).toEqual([]);
-	});
-
-	// spec: content.artifacts enabled + a TUI host -> the injected view opens once, with the host's own
-	//   ctx, no notify, and no registry write (SA §7: /canvas reads state, never writes it).
-	// fails_when: the view never opens, opens twice, gets a rebuilt ctx, or the command writes settings —
-	//   the positive control that keeps AC-4 from passing on a command that never acts at all.
-	test("AC-4 positive control: an enabled TUI host opens the injected view", async () => {
-		const h = harness(ENABLED);
-
-		const run = await runCanvas(h, "tui");
-
-		expect(h.opened).toHaveLength(1);
-		expect(h.opened[0]).toBe(run.ctx);
-		expect(run.notices).toEqual([]);
-		expect(h.saved).toEqual([]);
-	});
-});

package/src/core/code-theme.test.ts

@@ -1,266 +0,0 @@
-/**
- * code-theme.test.ts — the spec of createCodeTheme at its seam, with a counting engine double.
- *
- * Spec: createCodeTheme(bindEngine, {registry, log}) resolves `codeTheme` to a bundled name (unknown →
- * dracula-soft + one log line), highlights once per theme+lang+code, never hands the engine an empty or
- * over-80k block, and returns plain source lines when the engine or the bind throws.
- */
-
-import { describe, expect, it } from "vitest";
-import { type BindHighlightEngine, CODE_THEME_MODULE, type CodeThemeName, createCodeTheme } from "./code-theme.ts";
-
-// invented: the engine is faked, so the block only has to be two stable lines.
-const CODE = "const a = 1;\nlet b = 2;";
-
-/** One engine invocation: the theme it was bound to, plus the block it was asked for. */
-interface EngineCall {
-	theme: CodeThemeName;
-	code: string;
-	lang: string;
-}
-
-/**
- * Engine double that counts: it records every call and stamps its bound theme into the lines, so the
- * resolved theme is visible in the output rather than only in the bind argument.
- */
-function countingEngine(options: { throwOnBind?: boolean; throwOnCall?: boolean } = {}): {
-	bind: BindHighlightEngine;
-	calls: EngineCall[];
-} {
-	const calls: EngineCall[] = [];
-	const bind: BindHighlightEngine = (theme) => {
-		if (options.throwOnBind) throw new Error("bind failed");
-		return (code, lang) => {
-			calls.push({ theme, code, lang });
-			if (options.throwOnCall) throw new Error("engine failed");
-			return code.split("\n").map((line) => `«${theme}»${line}`);
-		};
-	};
-	return { bind, calls };
-}
-
-/** Logger double: logOnce's once-per-key rule plus the readout, so "exactly one line" is observable. */
-function logDouble(): {
-	logOnce(key: string, scope: string, message: string): void;
-	entries: Array<{ key: string; scope: string; message: string }>;
-	attempts: number;
-} {
-	const entries: Array<{ key: string; scope: string; message: string }> = [];
-	const seen = new Set<string>();
-	const double = {
-		entries,
-		attempts: 0,
-		logOnce(key: string, scope: string, message: string): void {
-			double.attempts += 1;
-			if (seen.has(key)) return;
-			seen.add(key);
-			entries.push({ key, scope, message });
-		},
-	};
-	return double;
-}
-
-/**
- * Settings double over the injected contract. invented: the slice is contracted as
- * `Record<string, unknown>`, so any bag is a legal stored document; `set` models the registry's
- * "a write lands on the next read".
- */
-function registryDouble(initial: Record<string, unknown> = {}): {
-	getSettings(key: string): Record<string, unknown>;
-	set(patch: Record<string, unknown>): void;
-} {
-	const slices = new Map<string, Record<string, unknown>>([["codetheme", { ...initial }]]);
-	return {
-		getSettings: (key) => slices.get(key) ?? {},
-		set: (patch) => slices.set("codetheme", { ...(slices.get("codetheme") ?? {}), ...patch }),
-	};
-}
-
-describe("createCodeTheme — theme resolution", () => {
-	it("AC-1: an unknown codeTheme renders the default theme and logs exactly one line", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		// invented: the setting is persisted JSON, so an out-of-set name is the exact input AC-1 names.
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "nope" }), log });
-
-		const first = await theme.highlight(CODE, "ts");
-		const second = await theme.highlight(CODE, "ts");
-		const joined = theme.highlightSync(CODE, "ts");
-
-		// fails_when: a crash, empty output, or one log line per call.
-		expect(first).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-		expect([second, joined]).toEqual([first, first.join("\n")]);
-		expect(engine.calls.map((call) => call.theme)).toEqual(["dracula-soft"]);
-		expect(log.entries.map((entry) => entry.key)).toEqual(["theme:nope"]);
-		expect(log.entries[0]?.message).toContain("dracula-soft");
-		expect(log.attempts).toBe(3);
-	});
-
-	it("AC-1: a bundled non-default theme is rendered without a log line", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "one-dark-pro" }), log });
-
-		// fails_when: the setting is ignored and the default theme always renders.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«one-dark-pro»const a = 1;", "«one-dark-pro»let b = 2;"]);
-		expect(log.entries).toEqual([]);
-	});
-
-	it("AC-1: an absent setting reads the default theme silently", async () => {
-		const engine = countingEngine();
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble(), log });
-
-		// fails_when: a fresh install logs a fallback line on every render.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-		expect(log.entries).toEqual([]);
-	});
-
-	it("AC-1: the descriptor is exported for T-28, and the injected registry has no write route", async () => {
-		// The injected registry shape is read-only (getSettings only), so a registration here cannot compile.
-		expect(CODE_THEME_MODULE).toEqual({
-			key: "codetheme",
-			name: "Code theme",
-			defaultEnabled: true,
-			settings: [
-				{ name: "codeTheme", kind: "enum", values: ["dracula-soft", "one-dark-pro"], default: "dracula-soft" },
-			],
-		});
-	});
-});
-
-describe("createCodeTheme — cache", () => {
-	it("AC-2: the same theme+lang+code highlights once", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		const first = await theme.highlight(CODE, "ts");
-		const second = await theme.highlight(CODE, "ts");
-
-		// fails_when: every call re-highlights (the #21 defect class).
-		expect(second).toEqual(first);
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-2: lang and theme are part of the key", async () => {
-		const engine = countingEngine();
-		const registry = registryDouble({ codeTheme: "dracula-soft" });
-		const theme = createCodeTheme(engine.bind, { registry });
-
-		await theme.highlight(CODE, "ts");
-		await theme.highlight(CODE, "py");
-		registry.set({ codeTheme: "one-dark-pro" });
-		await theme.highlight(CODE, "ts");
-
-		// fails_when: the key ignores lang or theme and serves the previous theme's colours.
-		expect(engine.calls.map((call) => `${call.theme}:${call.lang}`)).toEqual([
-			"dracula-soft:ts",
-			"dracula-soft:py",
-			"one-dark-pro:ts",
-		]);
-	});
-
-	it("AC-2: highlightSync shares the cache with highlight", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		await theme.highlight(CODE, "ts");
-		const joined = theme.highlightSync(CODE, "ts");
-
-		// fails_when: the panel path keeps a second cache and highlights the same block again.
-		expect(joined).toBe("«dracula-soft»const a = 1;\n«dracula-soft»let b = 2;");
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-2: the cache is bounded at 128 entries and a hit counts as recent use", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		for (let i = 0; i < 128; i += 1) await theme.highlight(`line ${i}`, "ts");
-		await theme.highlight("line 0", "ts");
-		await theme.highlight("line 128", "ts");
-		expect(engine.calls).toHaveLength(129); // the 129th entry evicted the oldest untouched one
-
-		// fails_when: the cache grows without bound, or a hit does not count as recent use.
-		expect(await theme.highlight("line 0", "ts")).toEqual(["«dracula-soft»line 0"]);
-		expect(engine.calls).toHaveLength(129);
-		expect(await theme.highlight("line 1", "ts")).toEqual(["«dracula-soft»line 1"]);
-		expect(engine.calls).toHaveLength(130);
-	});
-});
-
-describe("createCodeTheme — what never reaches the engine", () => {
-	it("AC-3: a block past 80k characters returns its own plain lines", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-		// invented: one character past the ported 80_000 gate (P render.ts:86).
-		const over = `x${"y".repeat(80_000)}`;
-
-		// fails_when: a blob this size enters shiki.
-		expect(await theme.highlight(over, "ts")).toEqual([over]);
-		expect(engine.calls).toEqual([]);
-
-		// the gate is strict: exactly 80_000 characters reach the engine.
-		await theme.highlight("y".repeat(80_000), "ts");
-		expect(engine.calls).toHaveLength(1);
-	});
-
-	it("AC-3: empty code returns one empty line", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: an empty block enters shiki, or the panel path emits a stray newline.
-		expect(await theme.highlight("", "ts")).toEqual([""]);
-		expect(theme.highlightSync("", "ts")).toBe("");
-		expect(engine.calls).toEqual([]);
-	});
-});
-
-describe("createCodeTheme — degradation", () => {
-	it("AC-4: a throwing engine returns plain lines and nothing escapes", async () => {
-		const engine = countingEngine({ throwOnCall: true });
-		const log = logDouble();
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }), log });
-
-		// fails_when: a shiki failure kills a render.
-		await expect(theme.highlight(CODE, "ts")).resolves.toEqual(["const a = 1;", "let b = 2;"]);
-		expect(theme.highlightSync(CODE, "ts")).toBe("const a = 1;\nlet b = 2;");
-		expect(log.entries.map((entry) => entry.key)).toEqual(["fail:ts"]);
-	});
-
-	it("AC-4: a throwing engine bind degrades the same way", async () => {
-		const engine = countingEngine({ throwOnBind: true });
-		const theme = createCodeTheme(engine.bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: a bind failure (shiki not loaded yet, a bad theme) escapes into the render path.
-		await expect(theme.highlight(CODE, "ts")).resolves.toEqual(["const a = 1;", "let b = 2;"]);
-	});
-
-	it("AC-4: an engine with no registry and no logger still highlights and still degrades", async () => {
-		const engine = countingEngine();
-		const theme = createCodeTheme(engine.bind);
-
-		// fails_when: the optional collaborators are required, so a bare construction throws.
-		expect(await theme.highlight(CODE, "ts")).toEqual(["«dracula-soft»const a = 1;", "«dracula-soft»let b = 2;"]);
-	});
-});
-
-describe("createCodeTheme — contrast normalization (P render.ts:112-140)", () => {
-	it("drops a foreground below the readability floor and keeps the rest", async () => {
-		// invented: RGB triples chosen around the 72 luminance floor (20 below, 80 just above) and the
-		// indexed-black form P treated as dark.
-		const DIM = "\u001b[38;2;20;20;20m";
-		const INDEXED = "\u001b[38;5;0m";
-		const READABLE = "\u001b[38;2;80;80;80m";
-		const RESET = "\u001b[0m";
-		const bind: BindHighlightEngine = () => () => [
-			`${DIM}dim${RESET}`,
-			`${INDEXED}indexed${RESET}`,
-			`${READABLE}readable${RESET}`,
-		];
-		const theme = createCodeTheme(bind, { registry: registryDouble({ codeTheme: "dracula-soft" }) });
-
-		// fails_when: an unreadable near-black token survives to the terminal.
-		expect(await theme.highlight("x", "ts")).toEqual([`dim${RESET}`, `indexed${RESET}`, `${READABLE}readable${RESET}`]);
-	});
-});

package/src/core/log.test.ts

@@ -1,127 +0,0 @@
-/**
- * log.test.ts — createLogger's behavior through its seam: logLine / logOnce in, drain() out (T-06).
- *
- * No module internals appear here; every assertion reads the entries a test or the future /render
- * panel would read back.
- *
- * shape: none — test module, no runtime unit for DSG-1's trigger table to select a shape for.
- */
-// invented fixtures: the keys, scopes, and messages below are plain strings with no upstream payload to
-// record; "tool:call-42" is the key shape named in src/core/types/log.ts.
-import { describe, expect, test, vi } from "vitest";
-import { createLogger } from "./log.ts";
-
-describe("createLogger", () => {
-	// spec: logOnce(key, …) appends one entry for a key; each distinct key appends its own.
-	// fails_when: a repeated key adds a duplicate entry, or a second key collides onto the first.
-	test("AC-1 logOnce keeps one entry per key, distinct keys do not collide", () => {
-		const logger = createLogger();
-
-		logger.logOnce("tool:call-42", "tool.bash", "first");
-		logger.logOnce("tool:call-42", "tool.bash", "repeat of the same key");
-		logger.logOnce("tool:call-43", "tool.bash", "a different key");
-
-		expect(logger.drain().map((entry) => entry.message)).toEqual(["first", "a different key"]);
-	});
-
-	// spec: any sequence of logging calls returns without throwing, including drain() on a logger with
-	//   no entries; the render path calls these, so a throw is a permanently broken row.
-	// fails_when: a logging call throws — the render path can be broken by its own diagnostics.
-	test("AC-2 no logging call throws, even on hostile text", () => {
-		const logger = createLogger();
-		const longText = "x".repeat(200_000);
-
-		expect(logger.drain()).toEqual([]);
-
-		expect(() => {
-			logger.logLine("", "");
-			logger.logLine("tool.bash", "line\nwith newlines\tand a 🖼 surrogate pair");
-			logger.logLine("tool.bash", longText);
-			logger.logOnce("tool:call-42", "tool.bash", longText);
-			logger.logOnce("tool:call-42", "tool.bash", "repeat");
-			logger.drain();
-		}).not.toThrow();
-
-		expect(logger.drain()).toEqual([]);
-	});
-
-	// spec: a logging call writes nothing to process.stdout or process.stderr — pi owns the terminal
-	//   for the TUI, so a write lands inside the rendered frame.
-	// fails_when: a diagnostic leaks to the terminal.
-	test("AC-3 logging writes neither stdout nor stderr", () => {
-		const logger = createLogger();
-		const stdout = vi.spyOn(process.stdout, "write").mockReturnValue(true);
-		const stderr = vi.spyOn(process.stderr, "write").mockReturnValue(true);
-
-		try {
-			logger.logLine("tool.bash", "line");
-			logger.logOnce("tool:call-42", "tool.bash", "once");
-			logger.logOnce("tool:call-42", "tool.bash", "once");
-			expect(logger.drain()).toHaveLength(2);
-			// Asserted before mockRestore(): restoring also discards the recorded calls.
-			expect(stdout).not.toHaveBeenCalled();
-			expect(stderr).not.toHaveBeenCalled();
-		} finally {
-			stdout.mockRestore();
-			stderr.mockRestore();
-		}
-	});
-
-	// spec: logLine(scope, message) leaves the entry attributable — that scope, that message, and a
-	//   capture time inside the call window.
-	// fails_when: entries cannot be attributed to the module that logged them.
-	test("AC-4 each entry keeps its scope, message, and capture time", () => {
-		const logger = createLogger();
-		const before = Date.now();
-
-		logger.logLine("find", "no matches");
-		logger.logOnce("tool:call-42", "tool.bash", "degraded row");
-
-		const after = Date.now();
-		const entries = logger.drain();
-
-		expect(entries.map((entry) => entry.scope)).toEqual(["find", "tool.bash"]);
-		expect(entries.map((entry) => entry.message)).toEqual(["no matches", "degraded row"]);
-		for (const entry of entries) {
-			expect(entry.time).toBeGreaterThanOrEqual(before);
-			expect(entry.time).toBeLessThanOrEqual(after);
-		}
-	});
-
-	// spec: past 256 entries the newest 256 survive in order and the oldest are dropped.
-	// fails_when: the buffer grows unbounded, or it drops the newest instead of the oldest.
-	test("AC-5 more than 256 entries keeps the newest 256 in order", () => {
-		const logger = createLogger();
-		for (let i = 0; i < 300; i += 1) logger.logLine("loop", `line-${i}`);
-
-		const messages = logger.drain().map((entry) => entry.message);
-
-		expect(messages).toHaveLength(256);
-		expect(messages.at(0)).toBe("line-44");
-		expect(messages.at(-1)).toBe("line-299");
-	});
-
-	// spec: drain() returns every captured entry in log order, and the buffer is empty afterwards.
-	// fails_when: a drained buffer still holds entries, so a panel re-shows the same lines.
-	test("drain() returns every captured entry and then empties the buffer", () => {
-		const logger = createLogger();
-		logger.logLine("tool.bash", "one");
-		logger.logLine("find", "two");
-
-		expect(logger.drain().map((entry) => entry.scope)).toEqual(["tool.bash", "find"]);
-		expect(logger.drain()).toEqual([]);
-	});
-
-	// spec: "at most one entry per key" is a property of the logger, not of the current buffer — a
-	//   panel that drains every frame must not re-emit a key's line.
-	// fails_when: drain() clears the dedup marks, so the same key logs again after a readout.
-	test("logOnce keeps a key spent across drain()", () => {
-		const logger = createLogger();
-		logger.logOnce("tool:call-42", "tool.bash", "once");
-		logger.drain();
-
-		logger.logOnce("tool:call-42", "tool.bash", "again");
-
-		expect(logger.drain()).toEqual([]);
-	});
-});