@os-eco/overstory-cli 0.7.5 → 0.7.7

package/README.md

@@ -6,7 +6,7 @@ Multi-agent orchestration for AI coding agents.
 [![CI](https://github.com/jayminwest/overstory/actions/workflows/ci.yml/badge.svg)](https://github.com/jayminwest/overstory/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-Overstory turns a single coding session into a multi-agent team by spawning worker agents in git worktrees via tmux, coordinating them through a custom SQLite mail system, and merging their work back with tiered conflict resolution. A pluggable `AgentRuntime` interface lets you swap between runtimes — Claude Code, [Pi](https://github.com/nichochar/pi-coding-agent), or your own adapter.
+Overstory turns a single coding session into a multi-agent team by spawning worker agents in git worktrees via tmux, coordinating them through a custom SQLite mail system, and merging their work back with tiered conflict resolution. A pluggable `AgentRuntime` interface lets you swap between runtimes — Claude Code, [Pi](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent), or your own adapter.
 
 > **Warning: Agent swarms are not a universal solution.** Do not deploy Overstory without understanding the risks of multi-agent orchestration — compounding error rates, cost amplification, debugging complexity, and merge conflicts are the normal case, not edge cases. Read [STEELMAN.md](STEELMAN.md) for a full risk analysis and the [Agentic Engineering Book](https://github.com/jayminwest/agentic-engineering-book) ([web version](https://jayminwest.com/agentic-engineering-book)) before using this tool in production.
 
@@ -15,7 +15,9 @@ Overstory turns a single coding session into a multi-agent team by spawning work
 Requires [Bun](https://bun.sh) v1.0+, git, and tmux. At least one supported agent runtime must be installed:
 
 - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude` CLI)
-- [Pi](https://github.com/nichochar/pi-coding-agent) (`pi` CLI)
+- [Pi](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) (`pi` CLI)
+- [GitHub Copilot](https://github.com/features/copilot) (`copilot` CLI)
+- [Codex](https://github.com/openai/codex) (`codex` CLI)
 
 ```bash
 bun install -g @os-eco/overstory-cli
@@ -77,7 +79,7 @@ Every command supports `--json` where noted. Global flags: `-q`/`--quiet`, `--ti
 
 | Command | Description |
 |---------|-------------|
-| `ov init` | Initialize `.overstory/` in current project (`--yes`, `--name`) |
+| `ov init` | Initialize `.overstory/` and bootstrap os-eco tools (`--yes`, `--name`, `--tools`, `--skip-mulch`, `--skip-seeds`, `--skip-canopy`, `--skip-onboard`, `--json`) |
 | `ov sling <task-id>` | Spawn a worker agent (`--capability`, `--name`, `--spec`, `--files`, `--parent`, `--depth`, `--skip-scout`, `--skip-review`, `--max-agents`, `--dispatch-max-agents`, `--skip-task-check`, `--no-scout-check`, `--runtime`, `--json`) |
 | `ov stop <agent-name>` | Terminate a running agent (`--clean-worktree`, `--json`) |
 | `ov prime` | Load context for orchestrator/agent (`--agent`, `--compact`) |
@@ -132,7 +134,7 @@ Every command supports `--json` where noted. Global flags: `-q`/`--quiet`, `--ti
 | `ov replay` | Interleaved chronological replay (`--run`, `--agent`, `--since`, `--until`, `--limit`, `--json`) |
 | `ov feed` | Unified real-time event stream (`--follow`, `--interval`, `--agent`, `--run`, `--json`) |
 | `ov logs` | Query NDJSON logs across agents (`--agent`, `--level`, `--since`, `--until`, `--follow`, `--json`) |
-| `ov costs` | Token/cost analysis and breakdown (`--live`, `--self`, `--agent`, `--run`, `--by-capability`, `--last`, `--json`) |
+| `ov costs` | Token/cost analysis and breakdown (`--live`, `--self`, `--agent`, `--run`, `--bead`, `--by-capability`, `--last`, `--json`) |
 | `ov metrics` | Show session metrics (`--last`, `--json`) |
 | `ov run list` | List orchestration runs (`--last`, `--json`) |
 | `ov run show <id>` | Show run details |
@@ -153,7 +155,7 @@ Every command supports `--json` where noted. Global flags: `-q`/`--quiet`, `--ti
 | `ov monitor status` | Show monitor state |
 | `ov log <event>` | Log a hook event (`--agent`) |
 | `ov clean` | Clean up worktrees, sessions, artifacts (`--completed`, `--all`, `--run`) |
-| `ov doctor` | Run health checks on overstory setup (`--category`, `--fix`, `--json`) |
+| `ov doctor` | Run health checks on overstory setup — 11 categories (`--category`, `--fix`, `--json`) |
 | `ov ecosystem` | Show os-eco tool versions and health (`--json`) |
 | `ov upgrade` | Upgrade overstory to latest npm version (`--check`, `--all`, `--json`) |
 | `ov agents discover` | Discover agents by capability/state/parent (`--capability`, `--state`, `--parent`, `--json`) |
@@ -171,6 +173,8 @@ Overstory is runtime-agnostic. The `AgentRuntime` interface (`src/runtimes/types
 |---------|-----|-----------------|--------|
 | Claude Code | `claude` | `settings.local.json` hooks | Stable |
 | Pi | `pi` | `.pi/extensions/` guard extension | Active development |
+| Copilot | `copilot` | (none — `--allow-all-tools`) | Active development |
+| Codex | `codex` | OS-level sandbox (Seatbelt/Landlock) | Active development |
 
 ## How It Works
 
@@ -240,7 +244,7 @@ overstory/
       run.ts                      Orchestration run lifecycle
       trace.ts                    Agent/task timeline viewing
       clean.ts                    Worktree/session cleanup
-      doctor.ts                   Health check runner (10 check modules)
+      doctor.ts                   Health check runner (11 check modules)
       inspect.ts                  Deep per-agent inspection
       spec.ts                     Task spec management
       errors.ts                   Aggregated error view
@@ -265,9 +269,9 @@ overstory/
     watchdog/                     Tiered health monitoring (daemon, triage, health)
     logging/                      Multi-format logger + sanitizer + reporter + color control + shared theme/format
     metrics/                      SQLite metrics + pricing + transcript parsing
-    doctor/                       Health check modules (10 checks)
+    doctor/                       Health check modules (11 checks)
     insights/                     Session insight analyzer for auto-expertise
-    runtimes/                     AgentRuntime abstraction (registry + adapters: Claude, Pi)
+    runtimes/                     AgentRuntime abstraction (registry + adapters: Claude, Pi, Copilot, Codex)
     tracker/                      Pluggable task tracker (beads + seeds backends)
     mulch/                        mulch client (programmatic API + CLI wrapper)
     e2e/                          End-to-end lifecycle tests

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@os-eco/overstory-cli",
-	"version": "0.7.5",
+	"version": "0.7.7",
 	"description": "Multi-agent orchestration for AI coding agents — spawn workers in git worktrees via tmux, coordinate through SQLite mail, merge with tiered conflict resolution. Pluggable runtime adapters for Claude Code, Pi, and more.",
 	"author": "Jaymin West",
 	"license": "MIT",

package/src/commands/agents.ts

@@ -10,6 +10,7 @@ import { loadConfig } from "../config.ts";
 import { ValidationError } from "../errors.ts";
 import { jsonOutput } from "../json.ts";
 import { accent, color } from "../logging/color.ts";
+import { getRuntime } from "../runtimes/registry.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import { type AgentSession, SUPPORTED_CAPABILITIES } from "../types.ts";
 
@@ -41,12 +42,19 @@ const KNOWN_INSTRUCTION_PATHS = [
  * or can't be read.
  *
  * @param worktreePath - Absolute path to the agent's worktree
+ * @param runtimeInstructionPath - Optional runtime-specific instruction path to try first
  * @returns Array of file paths (relative to worktree root)
  */
-export async function extractFileScope(worktreePath: string): Promise<string[]> {
+export async function extractFileScope(
+	worktreePath: string,
+	runtimeInstructionPath?: string,
+): Promise<string[]> {
 	try {
 		let content: string | null = null;
-		for (const relPath of KNOWN_INSTRUCTION_PATHS) {
+		const pathsToTry = runtimeInstructionPath
+			? [runtimeInstructionPath, ...KNOWN_INSTRUCTION_PATHS]
+			: KNOWN_INSTRUCTION_PATHS;
+		for (const relPath of pathsToTry) {
 			const overlayPath = join(worktreePath, relPath);
 			const overlayFile = Bun.file(overlayPath);
 			if (await overlayFile.exists()) {
@@ -112,6 +120,16 @@ export async function discoverAgents(
 	const overstoryDir = join(root, ".overstory");
 	const { store } = openSessionStore(overstoryDir);
 
+	// Resolve runtime instruction path from config; fall back gracefully if config is absent.
+	let runtimeInstructionPath: string | undefined;
+	try {
+		const config = await loadConfig(root);
+		const runtime = getRuntime(undefined, config);
+		runtimeInstructionPath = runtime.instructionPath;
+	} catch {
+		// Config may not exist in all contexts; KNOWN_INSTRUCTION_PATHS will be used as fallback.
+	}
+
 	try {
 		const sessions: AgentSession[] = opts?.includeAll ? store.getAll() : store.getActive();
 
@@ -124,7 +142,7 @@ export async function discoverAgents(
 		// Extract file scopes for each agent
 		const agents: DiscoveredAgent[] = await Promise.all(
 			filteredSessions.map(async (session) => {
-				const fileScope = await extractFileScope(session.worktreePath);
+				const fileScope = await extractFileScope(session.worktreePath, runtimeInstructionPath);
 				return {
 					agentName: session.agentName,
 					capability: session.capability,

package/src/commands/completions.ts

@@ -55,12 +55,18 @@ export const COMMANDS: readonly CommandDef[] = [
 	},
 	{
 		name: "init",
-		desc: "Initialize .overstory/ in current project",
+		desc: "Initialize .overstory/ and bootstrap os-eco ecosystem tools",
 		flags: [
 			{ name: "--force", desc: "Overwrite existing configuration" },
 			{ name: "--yes", desc: "Accept all defaults without prompting" },
 			{ name: "-y", desc: "Alias for --yes" },
 			{ name: "--name", desc: "Project name", takesValue: true },
+			{ name: "--tools", desc: "Comma-separated list of tools to bootstrap", takesValue: true },
+			{ name: "--skip-mulch", desc: "Skip mulch bootstrap" },
+			{ name: "--skip-seeds", desc: "Skip seeds bootstrap" },
+			{ name: "--skip-canopy", desc: "Skip canopy bootstrap" },
+			{ name: "--skip-onboard", desc: "Skip CLAUDE.md onboarding step" },
+			{ name: "--json", desc: "Output result as JSON" },
 			{ name: "--help", desc: "Show help" },
 		],
 	},

package/src/commands/costs.test.ts

@@ -1023,6 +1023,48 @@ describe("costsCommand", () => {
 		});
 	});
 
+	// === --bead filter ===
+
+	describe("--bead filter", () => {
+		test("--bead filters by task ID (JSON)", async () => {
+			const dbPath = join(tempDir, ".overstory", "metrics.db");
+			const store = createMetricsStore(dbPath);
+			store.recordSession(makeMetrics({ agentName: "builder-1", taskId: "task-A" }));
+			store.recordSession(makeMetrics({ agentName: "builder-2", taskId: "task-A" }));
+			store.recordSession(
+				makeMetrics({ agentName: "scout-1", taskId: "task-B", capability: "scout" }),
+			);
+			store.close();
+
+			await costsCommand(["--json", "--bead", "task-A"]);
+			const out = output();
+
+			const parsed = JSON.parse(out.trim()) as { sessions: Record<string, unknown>[] };
+			expect(parsed.sessions).toHaveLength(2);
+			expect(parsed.sessions.every((s) => s.taskId === "task-A")).toBe(true);
+		});
+
+		test("--bead returns empty for unknown task", async () => {
+			const dbPath = join(tempDir, ".overstory", "metrics.db");
+			const store = createMetricsStore(dbPath);
+			store.recordSession(makeMetrics({ agentName: "builder-1", taskId: "task-A" }));
+			store.close();
+
+			await costsCommand(["--json", "--bead", "nonexistent"]);
+			const out = output();
+
+			const parsed = JSON.parse(out.trim()) as { sessions: unknown[] };
+			expect(parsed.sessions).toEqual([]);
+		});
+
+		test("--bead appears in help text", async () => {
+			await costsCommand(["--help"]);
+			const out = output();
+
+			expect(out).toContain("--bead");
+		});
+	});
+
 	// === --self flag ===
 
 	describe("--self flag", () => {
@@ -1111,7 +1153,7 @@ describe("costsCommand", () => {
 			await costsCommand(["--self"]);
 			const out = output();
 
-			expect(out).toContain("No orchestrator transcript found");
+			expect(out).toContain("No transcript found");
 		});
 
 		test("--self --json outputs error JSON when no transcript found", async () => {
@@ -1122,7 +1164,8 @@ describe("costsCommand", () => {
 			const out = output();
 
 			const parsed = JSON.parse(out.trim()) as Record<string, unknown>;
-			expect(parsed.error).toBe("No orchestrator transcript found");
+			expect(typeof parsed.error).toBe("string");
+			expect(parsed.error as string).toContain("No transcript found");
 		});
 
 		test("--self in help text", async () => {

package/src/commands/costs.ts

@@ -16,6 +16,7 @@ import { color } from "../logging/color.ts";
 import { renderHeader, separator } from "../logging/theme.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { estimateCost, parseTranscriptUsage } from "../metrics/transcript.ts";
+import { getRuntime } from "../runtimes/registry.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import type { SessionMetrics } from "../types.ts";
 
@@ -43,24 +44,45 @@ function padLeft(str: string, width: number): string {
 }
 
 /**
- * Discover the orchestrator's Claude Code transcript JSONL file.
- *
- * Scans ~/.claude/projects/{project-key}/ for JSONL files and returns
- * the most recently modified one, corresponding to the current orchestrator session.
+ * Resolve the transcript directory for a given runtime and project root.
  *
+ * @param runtimeId - The runtime identifier (e.g. "claude")
  * @param projectRoot - Absolute path to the project root
- * @returns Absolute path to the most recent transcript, or null if none found
+ * @returns Absolute path to the transcript directory, or null if not supported
  */
-async function discoverOrchestratorTranscript(projectRoot: string): Promise<string | null> {
+function getTranscriptDir(runtimeId: string, projectRoot: string): string | null {
 	const homeDir = process.env.HOME ?? "";
 	if (homeDir.length === 0) return null;
+	switch (runtimeId) {
+		case "claude": {
+			const projectKey = projectRoot.replace(/\//g, "-");
+			return join(homeDir, ".claude", "projects", projectKey);
+		}
+		default:
+			return null;
+	}
+}
 
-	const projectKey = projectRoot.replace(/\//g, "-");
-	const projectDir = join(homeDir, ".claude", "projects", projectKey);
+/**
+ * Discover the orchestrator's transcript JSONL file for the given runtime.
+ *
+ * Scans the runtime-specific transcript directory for JSONL files and returns
+ * the most recently modified one, corresponding to the current orchestrator session.
+ *
+ * @param runtimeId - The runtime identifier (e.g. "claude")
+ * @param projectRoot - Absolute path to the project root
+ * @returns Absolute path to the most recent transcript, or null if none found
+ */
+async function discoverOrchestratorTranscript(
+	runtimeId: string,
+	projectRoot: string,
+): Promise<string | null> {
+	const transcriptDir = getTranscriptDir(runtimeId, projectRoot);
+	if (transcriptDir === null) return null;
 
 	let entries: string[];
 	try {
-		entries = await readdir(projectDir);
+		entries = await readdir(transcriptDir);
 	} catch {
 		return null;
 	}
@@ -72,7 +94,7 @@ async function discoverOrchestratorTranscript(projectRoot: string): Promise<stri
 	let bestMtime = 0;
 
 	for (const file of jsonlFiles) {
-		const filePath = join(projectDir, file);
+		const filePath = join(transcriptDir, file);
 		try {
 			const fileStat = await stat(filePath);
 			if (fileStat.mtimeMs > bestMtime) {
@@ -236,6 +258,7 @@ interface CostsOpts {
 	byCapability?: boolean;
 	agent?: string;
 	run?: string;
+	bead?: string;
 	last?: string;
 	json?: boolean;
 }
@@ -247,6 +270,7 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 	const byCapability = opts.byCapability ?? false;
 	const agentName = opts.agent;
 	const runId = opts.run;
+	const beadId = opts.bead;
 	const lastStr = opts.last;
 
 	if (lastStr !== undefined) {
@@ -267,13 +291,15 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 
 	// Handle --self flag (early return for self-scan)
 	if (self) {
-		const transcriptPath = await discoverOrchestratorTranscript(config.project.root);
+		const runtime = getRuntime(undefined, config);
+		const transcriptPath = await discoverOrchestratorTranscript(runtime.id, config.project.root);
 		if (!transcriptPath) {
 			if (json) {
-				jsonError("costs", "No orchestrator transcript found");
+				jsonError("costs", `No transcript found for runtime '${runtime.id}'`);
 			} else {
 				process.stdout.write(
-					"No orchestrator transcript found.\nExpected at: ~/.claude/projects/{project-key}/*.jsonl\n",
+					`No transcript found for runtime '${runtime.id}'.\n` +
+						"Transcript discovery may not be supported for this runtime.\n",
 				);
 			}
 			return;
@@ -521,6 +547,8 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 			sessions = metricsStore.getSessionsByAgent(agentName);
 		} else if (runId !== undefined) {
 			sessions = metricsStore.getSessionsByRun(runId);
+		} else if (beadId !== undefined) {
+			sessions = metricsStore.getSessionsByTask(beadId);
 		} else {
 			sessions = metricsStore.getRecentSessions(last);
 		}
@@ -559,6 +587,7 @@ export function createCostsCommand(): Command {
 		.option("--self", "Show cost for the current orchestrator session")
 		.option("--agent <name>", "Filter by agent name")
 		.option("--run <id>", "Filter by run ID")
+		.option("--bead <id>", "Show cost breakdown for a specific task/bead")
 		.option("--by-capability", "Group results by capability with subtotals")
 		.option("--last <n>", "Number of recent sessions (default: 20)")
 		.option("--json", "Output as JSON")

package/src/commands/dashboard.test.ts

@@ -21,6 +21,7 @@ import {
 	computeAgentPanelHeight,
 	dashboardCommand,
 	dimBox,
+	EventBuffer,
 	filterAgentsByRun,
 	horizontalLine,
 	openDashboardStores,
@@ -242,28 +243,28 @@ describe("dimBox", () => {
 
 describe("computeAgentPanelHeight", () => {
 	test("0 agents: clamps to minimum 8", () => {
-		// max(8, min(floor(30*0.5), 0+4)) = max(8, min(15,4)) = max(8,4) = 8
+		// max(8, min(floor(30*0.35)=10, 0+4)) = max(8, min(10,4)) = max(8,4) = 8
 		expect(computeAgentPanelHeight(30, 0)).toBe(8);
 	});
 
 	test("4 agents: still clamps to minimum 8", () => {
-		// max(8, min(15, 4+4)) = max(8, 8) = 8
+		// max(8, min(10, 4+4)) = max(8, 8) = 8
 		expect(computeAgentPanelHeight(30, 4)).toBe(8);
 	});
 
-	test("20 agents with height 30: clamps to floor(height*0.5)", () => {
-		// max(8, min(15, 24)) = max(8,15) = 15
-		expect(computeAgentPanelHeight(30, 20)).toBe(15);
+	test("20 agents with height 30: clamps to floor(height*0.35)", () => {
+		// max(8, min(floor(30*0.35)=10, 24)) = max(8,10) = 10
+		expect(computeAgentPanelHeight(30, 20)).toBe(10);
 	});
 
 	test("10 agents with height 30: grows with agent count", () => {
-		// max(8, min(15, 14)) = max(8,14) = 14
-		expect(computeAgentPanelHeight(30, 10)).toBe(14);
+		// max(8, min(10, 14)) = max(8,10) = 10
+		expect(computeAgentPanelHeight(30, 10)).toBe(10);
 	});
 
-	test("small height: respects 50% cap", () => {
-		// height=20: max(8, min(10, 20+4)) = max(8,10) = 10
-		expect(computeAgentPanelHeight(20, 20)).toBe(10);
+	test("small height: respects 35% cap", () => {
+		// height=20: max(8, min(floor(20*0.35)=7, 24)) = max(8,7) = 8
+		expect(computeAgentPanelHeight(20, 20)).toBe(8);
 	});
 });
 
@@ -302,6 +303,7 @@ function makeDashboardData(
 		metrics: { totalSessions: 0, avgDuration: 0, byCapability: {} },
 		tasks: overrides.tasks ?? [],
 		recentEvents: (overrides.recentEvents as never[]) ?? [],
+		feedColorMap: new Map(),
 	};
 }
 
@@ -366,6 +368,7 @@ describe("renderFeedPanel", () => {
 		const data = makeDashboardData({ recentEvents: [] });
 		const out = renderFeedPanel(data, 1, 80, 8, 1);
 		expect(out).toContain("Feed");
+		expect(out).toContain("(live)");
 	});
 
 	test("renders event agent name when events are present", () => {
@@ -554,6 +557,94 @@ describe("closeDashboardStores", () => {
 	});
 });
 
+describe("EventBuffer", () => {
+	let tempDir: string;
+
+	beforeEach(async () => {
+		tempDir = await mkdtemp(join(tmpdir(), "event-buffer-test-"));
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tempDir);
+	});
+
+	function makeEvent(agentName: string) {
+		return {
+			agentName,
+			eventType: "tool_end" as const,
+			level: "info" as const,
+			runId: null,
+			sessionId: null,
+			toolName: null,
+			toolArgs: null,
+			toolDurationMs: null,
+			data: null,
+		};
+	}
+
+	test("starts empty", () => {
+		const buf = new EventBuffer();
+		expect(buf.size).toBe(0);
+		expect(buf.getEvents()).toEqual([]);
+	});
+
+	test("poll adds events from event store", async () => {
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+		const store = createEventStore(join(overstoryDir, "events.db"));
+		store.insert(makeEvent("agent-a"));
+
+		const buf = new EventBuffer();
+		buf.poll(store);
+		expect(buf.size).toBe(1);
+		store.close();
+	});
+
+	test("deduplicates by lastSeenId (double poll returns same count)", async () => {
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+		const store = createEventStore(join(overstoryDir, "events.db"));
+		store.insert(makeEvent("agent-a"));
+
+		const buf = new EventBuffer();
+		buf.poll(store);
+		buf.poll(store); // second poll should not duplicate
+		expect(buf.size).toBe(1);
+		store.close();
+	});
+
+	test("trims to maxSize keeping most recent events", async () => {
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+		const store = createEventStore(join(overstoryDir, "events.db"));
+		for (let i = 0; i < 5; i++) {
+			store.insert(makeEvent(`agent-${i}`));
+		}
+
+		const buf = new EventBuffer(3);
+		buf.poll(store);
+		expect(buf.size).toBe(3);
+		store.close();
+	});
+
+	test("builds color map across polls", async () => {
+		const overstoryDir = join(tempDir, ".overstory");
+		await mkdir(overstoryDir, { recursive: true });
+		const store = createEventStore(join(overstoryDir, "events.db"));
+		store.insert(makeEvent("agent-x"));
+
+		const buf = new EventBuffer();
+		buf.poll(store);
+		expect(buf.getColorMap().has("agent-x")).toBe(true);
+
+		store.insert(makeEvent("agent-y"));
+		buf.poll(store);
+		expect(buf.getColorMap().has("agent-x")).toBe(true);
+		expect(buf.getColorMap().has("agent-y")).toBe(true);
+		store.close();
+	});
+});
+
 // Type check: DashboardStores includes eventStore
 test("DashboardStores type includes eventStore field", () => {
 	const stores: DashboardStores = {