@ag-eco/agentplate-cli 0.13.0

package/src/commands/replay.ts

@@ -0,0 +1,231 @@
+/**
+ * CLI command: ap replay [--run <id>] [--agent <name>...] [--json]
+ *              [--since <ts>] [--until <ts>] [--limit <n>]
+ *
+ * Shows an interleaved chronological replay of events across multiple agents.
+ * Like reading a combined log — all agents' events merged by timestamp.
+ */
+
+import { join } from "node:path";
+import { Command } from "commander";
+import { loadConfig } from "../config.ts";
+import { ValidationError } from "../errors.ts";
+import { createEventStore } from "../events/store.ts";
+import { jsonOutput } from "../json.ts";
+import { color } from "../logging/color.ts";
+import {
+	buildAgentColorMap,
+	buildEventDetail,
+	formatAbsoluteTime,
+	formatDate,
+	formatRelativeTime,
+} from "../logging/format.ts";
+import { eventLabel, renderHeader } from "../logging/theme.ts";
+import type { StoredEvent } from "../types.ts";
+
+/**
+ * Print events as an interleaved timeline with ANSI colors and agent labels.
+ */
+function printReplay(events: StoredEvent[], useAbsoluteTime: boolean): void {
+	const w = process.stdout.write.bind(process.stdout);
+
+	w(`${renderHeader("Replay")}\n`);
+
+	if (events.length === 0) {
+		w(`${color.dim("No events found.")}\n`);
+		return;
+	}
+
+	w(`${color.dim(`${events.length} event${events.length === 1 ? "" : "s"}`)}\n\n`);
+
+	const colorMap = buildAgentColorMap(events);
+	let lastDate = "";
+
+	for (const event of events) {
+		// Print date separator when the date changes
+		const date = formatDate(event.createdAt);
+		if (date && date !== lastDate) {
+			if (lastDate !== "") {
+				w("\n");
+			}
+			w(`${color.dim(`--- ${date} ---`)}\n`);
+			lastDate = date;
+		}
+
+		const timeStr = useAbsoluteTime
+			? formatAbsoluteTime(event.createdAt)
+			: formatRelativeTime(event.createdAt);
+
+		const label = eventLabel(event.eventType);
+
+		const levelColorFn =
+			event.level === "error" ? color.red : event.level === "warn" ? color.yellow : null;
+		const applyLevel = (text: string) => (levelColorFn ? levelColorFn(text) : text);
+
+		const detail = buildEventDetail(event);
+		const detailSuffix = detail ? ` ${color.dim(detail)}` : "";
+
+		const agentColorFn = colorMap.get(event.agentName) ?? color.gray;
+		const agentLabel = ` ${agentColorFn(`[${event.agentName}]`)}`;
+
+		w(
+			`${color.dim(timeStr.padStart(10))} ` +
+				`${applyLevel(label.color(color.bold(label.full)))}` +
+				`${agentLabel}${detailSuffix}\n`,
+		);
+	}
+}
+
+interface ReplayOpts {
+	run?: string;
+	agent: string[]; // repeatable
+	since?: string;
+	until?: string;
+	limit?: string;
+	json?: boolean;
+}
+
+async function executeReplay(opts: ReplayOpts): Promise<void> {
+	const json = opts.json ?? false;
+	const runId = opts.run;
+	const agentNames = opts.agent;
+	const sinceStr = opts.since;
+	const untilStr = opts.until;
+	const limitStr = opts.limit;
+	const limit = limitStr ? Number.parseInt(limitStr, 10) : 200;
+
+	if (Number.isNaN(limit) || limit < 1) {
+		throw new ValidationError("--limit must be a positive integer", {
+			field: "limit",
+			value: limitStr,
+		});
+	}
+
+	// Validate timestamps if provided
+	if (sinceStr !== undefined && Number.isNaN(new Date(sinceStr).getTime())) {
+		throw new ValidationError("--since must be a valid ISO 8601 timestamp", {
+			field: "since",
+			value: sinceStr,
+		});
+	}
+	if (untilStr !== undefined && Number.isNaN(new Date(untilStr).getTime())) {
+		throw new ValidationError("--until must be a valid ISO 8601 timestamp", {
+			field: "until",
+			value: untilStr,
+		});
+	}
+
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const agentplateDir = join(config.project.root, ".agentplate");
+
+	// Open event store
+	const eventsDbPath = join(agentplateDir, "events.db");
+	const eventsFile = Bun.file(eventsDbPath);
+	if (!(await eventsFile.exists())) {
+		if (json) {
+			jsonOutput("replay", { events: [] });
+		} else {
+			process.stdout.write("No events data yet.\n");
+		}
+		return;
+	}
+
+	const eventStore = createEventStore(eventsDbPath);
+
+	try {
+		let events: StoredEvent[];
+		const queryOpts = { since: sinceStr, until: untilStr, limit };
+
+		if (runId) {
+			// Query by run ID
+			events = eventStore.getByRun(runId, queryOpts);
+		} else if (agentNames.length > 0) {
+			// Query each agent and merge
+			const allEvents: StoredEvent[] = [];
+			for (const name of agentNames) {
+				const agentEvents = eventStore.getByAgent(name, {
+					since: sinceStr,
+					until: untilStr,
+				});
+				allEvents.push(...agentEvents);
+			}
+			// Sort by createdAt chronologically
+			allEvents.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+			// Apply limit after merge
+			events = allEvents.slice(0, limit);
+		} else {
+			// Default: try current-run.txt, then fall back to 24h timeline
+			const currentRunPath = join(agentplateDir, "current-run.txt");
+			const currentRunFile = Bun.file(currentRunPath);
+			if (await currentRunFile.exists()) {
+				const currentRunId = (await currentRunFile.text()).trim();
+				if (currentRunId) {
+					events = eventStore.getByRun(currentRunId, queryOpts);
+				} else {
+					// Empty file, fall back to timeline
+					const since24h = sinceStr ?? new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+					events = eventStore.getTimeline({
+						since: since24h,
+						until: untilStr,
+						limit,
+					});
+				}
+			} else {
+				// No current run file, fall back to 24h timeline
+				const since24h = sinceStr ?? new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+				events = eventStore.getTimeline({
+					since: since24h,
+					until: untilStr,
+					limit,
+				});
+			}
+		}
+
+		if (json) {
+			jsonOutput("replay", { events });
+			return;
+		}
+
+		// Use absolute time if --since is specified, relative otherwise
+		const useAbsoluteTime = sinceStr !== undefined;
+		printReplay(events, useAbsoluteTime);
+	} finally {
+		eventStore.close();
+	}
+}
+
+export function createReplayCommand(): Command {
+	return new Command("replay")
+		.description("Interleaved chronological replay across agents")
+		.option("--run <id>", "Filter events by run ID")
+		.option(
+			"--agent <name>",
+			"Filter by agent name (can appear multiple times)",
+			(val: string, prev: string[]) => [...prev, val],
+			[] as string[],
+		)
+		.option("--since <timestamp>", "Start time filter (ISO 8601)")
+		.option("--until <timestamp>", "End time filter (ISO 8601)")
+		.option("--limit <n>", "Max events to show (default: 200)")
+		.option("--json", "Output as JSON array of StoredEvent objects")
+		.action(async (opts: ReplayOpts) => {
+			await executeReplay(opts);
+		});
+}
+
+export async function replayCommand(args: string[]): Promise<void> {
+	const cmd = createReplayCommand();
+	cmd.exitOverride();
+	try {
+		await cmd.parseAsync(args, { from: "user" });
+	} catch (err: unknown) {
+		if (err && typeof err === "object" && "code" in err) {
+			const code = (err as { code: string }).code;
+			if (code === "commander.helpDisplayed" || code === "commander.version") {
+				return;
+			}
+		}
+		throw err;
+	}
+}

package/src/commands/run.test.ts

@@ -0,0 +1,469 @@
+/**
+ * Tests for agentplate run command.
+ *
+ * Uses real SQLite (temp files) and real file I/O for current-run.txt.
+ * No mocks -- tests exercise the actual RunStore and SessionStore.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { SessionStore } from "../sessions/store.ts";
+import { createRunStore, createSessionStore } from "../sessions/store.ts";
+import { cleanupTempDir } from "../test-helpers.ts";
+import type { AgentSession, InsertRun, RunStore } from "../types.ts";
+
+let tempDir: string;
+let agentplateDir: string;
+let dbPath: string;
+let runStore: RunStore;
+let sessionStore: SessionStore;
+
+beforeEach(async () => {
+	tempDir = await mkdtemp(join(tmpdir(), "agentplate-run-test-"));
+	agentplateDir = join(tempDir, ".agentplate");
+	await mkdir(agentplateDir, { recursive: true });
+	dbPath = join(agentplateDir, "sessions.db");
+	runStore = createRunStore(dbPath);
+	sessionStore = createSessionStore(dbPath);
+});
+
+afterEach(async () => {
+	runStore.close();
+	sessionStore.close();
+	await cleanupTempDir(tempDir);
+});
+
+/** Write a run ID to current-run.txt. */
+async function writeCurrentRun(runId: string): Promise<void> {
+	await Bun.write(join(agentplateDir, "current-run.txt"), runId);
+}
+
+/** Read current-run.txt contents, or null if missing/empty. */
+async function readCurrentRunFile(): Promise<string | null> {
+	const file = Bun.file(join(agentplateDir, "current-run.txt"));
+	if (!(await file.exists())) {
+		return null;
+	}
+	const trimmed = (await file.text()).trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+
+/** Helper to create an InsertRun with optional overrides. */
+function makeRun(overrides: Partial<InsertRun> = {}): InsertRun {
+	return {
+		id: "run-2026-02-13T10:00:00.000Z",
+		startedAt: "2026-02-13T10:00:00.000Z",
+		coordinatorSessionId: "coord-session-001",
+		status: "active",
+		...overrides,
+	};
+}
+
+/** Helper to create an AgentSession with optional overrides. */
+function makeSession(overrides: Partial<AgentSession> = {}): AgentSession {
+	return {
+		id: "session-001",
+		agentName: "test-agent",
+		capability: "builder",
+		worktreePath: "/tmp/worktrees/test-agent",
+		branchName: "agentplate/test-agent/task-1",
+		taskId: "task-1",
+		tmuxSession: "agentplate-test-agent",
+		state: "working",
+		pid: 12345,
+		parentAgent: null,
+		depth: 0,
+		runId: null,
+		startedAt: "2026-02-13T10:00:00.000Z",
+		lastActivity: "2026-02-13T10:30:00.000Z",
+		escalationLevel: 0,
+		stalledSince: null,
+		transcriptPath: null,
+		...overrides,
+	};
+}
+
+// ============================================================
+// Direct function tests (testing the store interactions)
+// ============================================================
+
+describe("show current run (default)", () => {
+	test("shows 'No active run' when current-run.txt does not exist", async () => {
+		// No current-run.txt written -- file does not exist
+		const file = Bun.file(join(agentplateDir, "current-run.txt"));
+		expect(await file.exists()).toBe(false);
+	});
+
+	test("reads run ID from current-run.txt", async () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		await writeCurrentRun(runId);
+		const content = await readCurrentRunFile();
+		expect(content).toBe(runId);
+	});
+
+	test("fetches run details from RunStore", () => {
+		const run = makeRun();
+		runStore.createRun(run);
+
+		const fetched = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(fetched).not.toBeNull();
+		expect(fetched?.id).toBe("run-2026-02-13T10:00:00.000Z");
+		expect(fetched?.status).toBe("active");
+		expect(fetched?.agentCount).toBe(0);
+	});
+
+	test("returns null for missing run ID", () => {
+		const fetched = runStore.getRun("nonexistent");
+		expect(fetched).toBeNull();
+	});
+});
+
+describe("list runs", () => {
+	test("returns empty array when no runs exist", () => {
+		const runs = runStore.listRuns({ limit: 10 });
+		expect(runs).toEqual([]);
+	});
+
+	test("returns runs ordered by started_at descending", () => {
+		runStore.createRun(makeRun({ id: "run-1", startedAt: "2026-02-13T08:00:00.000Z" }));
+		runStore.createRun(makeRun({ id: "run-2", startedAt: "2026-02-13T12:00:00.000Z" }));
+		runStore.createRun(makeRun({ id: "run-3", startedAt: "2026-02-13T10:00:00.000Z" }));
+
+		const runs = runStore.listRuns({ limit: 10 });
+		expect(runs).toHaveLength(3);
+		expect(runs[0]?.id).toBe("run-2");
+		expect(runs[1]?.id).toBe("run-3");
+		expect(runs[2]?.id).toBe("run-1");
+	});
+
+	test("respects --last limit", () => {
+		for (let i = 0; i < 5; i++) {
+			runStore.createRun(
+				makeRun({
+					id: `run-${i}`,
+					startedAt: `2026-02-13T${String(10 + i).padStart(2, "0")}:00:00.000Z`,
+				}),
+			);
+		}
+
+		const runs = runStore.listRuns({ limit: 3 });
+		expect(runs).toHaveLength(3);
+	});
+
+	test("includes completed and active runs", () => {
+		runStore.createRun(makeRun({ id: "run-active", status: "active" }));
+		runStore.createRun(
+			makeRun({
+				id: "run-done",
+				startedAt: "2026-02-13T11:00:00.000Z",
+				status: "active",
+			}),
+		);
+		runStore.completeRun("run-done", "completed");
+
+		const runs = runStore.listRuns({ limit: 10 });
+		expect(runs).toHaveLength(2);
+		const statuses = runs.map((r) => r.status);
+		expect(statuses).toContain("active");
+		expect(statuses).toContain("completed");
+	});
+});
+
+describe("complete run", () => {
+	test("marks active run as completed in RunStore", () => {
+		runStore.createRun(makeRun());
+
+		runStore.completeRun("run-2026-02-13T10:00:00.000Z", "completed");
+
+		const run = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(run?.status).toBe("completed");
+		expect(run?.completedAt).not.toBeNull();
+	});
+
+	test("current-run.txt can be deleted after completion", async () => {
+		await writeCurrentRun("run-2026-02-13T10:00:00.000Z");
+		expect(await readCurrentRunFile()).toBe("run-2026-02-13T10:00:00.000Z");
+
+		// Simulate what completeCurrentRun does
+		await unlink(join(agentplateDir, "current-run.txt"));
+		const file = Bun.file(join(agentplateDir, "current-run.txt"));
+		expect(await file.exists()).toBe(false);
+	});
+
+	test("no active run returns null from readCurrentRunFile", async () => {
+		// No current-run.txt exists
+		const content = await readCurrentRunFile();
+		expect(content).toBeNull();
+	});
+
+	test("empty current-run.txt returns null", async () => {
+		await Bun.write(join(agentplateDir, "current-run.txt"), "");
+		const content = await readCurrentRunFile();
+		expect(content).toBeNull();
+	});
+
+	test("whitespace-only current-run.txt returns null", async () => {
+		await Bun.write(join(agentplateDir, "current-run.txt"), "  \n  ");
+		const content = await readCurrentRunFile();
+		expect(content).toBeNull();
+	});
+});
+
+describe("show run details", () => {
+	test("fetches run and its agents from stores", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+
+		sessionStore.upsert(
+			makeSession({
+				agentName: "builder-1",
+				id: "s-1",
+				runId,
+				capability: "builder",
+				state: "working",
+			}),
+		);
+		sessionStore.upsert(
+			makeSession({
+				agentName: "scout-1",
+				id: "s-2",
+				runId,
+				capability: "scout",
+				state: "completed",
+			}),
+		);
+
+		const run = runStore.getRun(runId);
+		expect(run).not.toBeNull();
+		// agentCount is derived from sessions in the same run.
+		expect(run?.agentCount).toBe(2);
+
+		const agents = sessionStore.getByRun(runId);
+		expect(agents).toHaveLength(2);
+		expect(agents.map((a) => a.agentName).sort()).toEqual(["builder-1", "scout-1"]);
+	});
+
+	test("agent count includes coordinator session in the same run (agentplate-8e69)", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+
+		// Coordinator + two children — all sharing the same run_id.
+		sessionStore.upsert(
+			makeSession({
+				agentName: "coordinator",
+				id: "s-coord",
+				runId,
+				capability: "coordinator",
+				state: "working",
+			}),
+		);
+		sessionStore.upsert(makeSession({ agentName: "lead-1", id: "s-1", runId, capability: "lead" }));
+		sessionStore.upsert(
+			makeSession({ agentName: "builder-1", id: "s-2", runId, capability: "builder" }),
+		);
+
+		const run = runStore.getRun(runId);
+		expect(run?.agentCount).toBe(3);
+		expect(sessionStore.getByRun(runId)).toHaveLength(3);
+	});
+
+	test("agent count drops when a session is removed", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+		sessionStore.upsert(makeSession({ agentName: "a", id: "s-1", runId }));
+		sessionStore.upsert(makeSession({ agentName: "b", id: "s-2", runId }));
+		expect(runStore.getRun(runId)?.agentCount).toBe(2);
+
+		sessionStore.remove("a");
+		expect(runStore.getRun(runId)?.agentCount).toBe(1);
+	});
+
+	test("returns null for missing run", () => {
+		const run = runStore.getRun("nonexistent-run");
+		expect(run).toBeNull();
+	});
+
+	test("returns empty agents for run with no sessions", () => {
+		runStore.createRun(makeRun());
+		const agents = sessionStore.getByRun("run-2026-02-13T10:00:00.000Z");
+		expect(agents).toEqual([]);
+	});
+
+	test("agents include capability and state", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+
+		sessionStore.upsert(
+			makeSession({
+				agentName: "reviewer-1",
+				id: "s-1",
+				runId,
+				capability: "reviewer",
+				state: "stalled",
+			}),
+		);
+
+		const agents = sessionStore.getByRun(runId);
+		expect(agents).toHaveLength(1);
+		expect(agents[0]?.capability).toBe("reviewer");
+		expect(agents[0]?.state).toBe("stalled");
+	});
+});
+
+describe("--json output mode", () => {
+	test("current run JSON includes run and duration", () => {
+		runStore.createRun(makeRun());
+		const run = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(run).not.toBeNull();
+
+		// Simulate JSON output structure
+		const output = JSON.stringify({ run, duration: "some-duration" });
+		const parsed = JSON.parse(output) as { run: unknown; duration: string };
+		expect(parsed.run).not.toBeNull();
+		expect(parsed.duration).toBe("some-duration");
+	});
+
+	test("list JSON includes runs array", () => {
+		runStore.createRun(makeRun({ id: "run-1" }));
+		runStore.createRun(makeRun({ id: "run-2", startedAt: "2026-02-13T11:00:00.000Z" }));
+
+		const runs = runStore.listRuns({ limit: 10 });
+		const output = JSON.stringify({ runs });
+		const parsed = JSON.parse(output) as { runs: unknown[] };
+		expect(parsed.runs).toHaveLength(2);
+	});
+
+	test("show JSON includes run and agents", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+		sessionStore.upsert(makeSession({ agentName: "a1", id: "s-1", runId }));
+
+		const run = runStore.getRun(runId);
+		const agents = sessionStore.getByRun(runId);
+
+		const output = JSON.stringify({ run, agents, duration: "1m 30s" });
+		const parsed = JSON.parse(output) as {
+			run: unknown;
+			agents: unknown[];
+			duration: string;
+		};
+		expect(parsed.run).not.toBeNull();
+		expect(parsed.agents).toHaveLength(1);
+		expect(parsed.duration).toBe("1m 30s");
+	});
+
+	test("no active run JSON returns null run", () => {
+		// No current-run.txt exists
+		const output = JSON.stringify({ run: null, message: "No active run" });
+		const parsed = JSON.parse(output) as { run: unknown; message: string };
+		expect(parsed.run).toBeNull();
+		expect(parsed.message).toBe("No active run");
+	});
+});
+
+describe("duration formatting", () => {
+	test("run with completedAt uses that for duration endpoint", () => {
+		runStore.createRun(makeRun());
+		runStore.completeRun("run-2026-02-13T10:00:00.000Z", "completed");
+
+		const run = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(run?.completedAt).not.toBeNull();
+
+		// Verify the start and end are both set, so duration can be computed
+		const start = new Date(run?.startedAt ?? "").getTime();
+		const end = new Date(run?.completedAt ?? "").getTime();
+		expect(end).toBeGreaterThan(start);
+	});
+
+	test("active run uses current time as duration endpoint", () => {
+		runStore.createRun(makeRun());
+
+		const run = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(run?.completedAt).toBeNull();
+		expect(run?.status).toBe("active");
+
+		// Duration should be from startedAt to now
+		const start = new Date(run?.startedAt ?? "").getTime();
+		expect(Date.now() - start).toBeGreaterThan(0);
+	});
+});
+
+describe("multiple runs lifecycle", () => {
+	test("create, use, complete multiple runs sequentially", async () => {
+		// Run 1: two sessions, then completed.
+		runStore.createRun(makeRun({ id: "run-1", startedAt: "2026-02-13T08:00:00.000Z" }));
+		await writeCurrentRun("run-1");
+		sessionStore.upsert(makeSession({ agentName: "r1-a", id: "s-r1-1", runId: "run-1" }));
+		sessionStore.upsert(makeSession({ agentName: "r1-b", id: "s-r1-2", runId: "run-1" }));
+		runStore.completeRun("run-1", "completed");
+
+		// Run 2: one session, still active.
+		runStore.createRun(makeRun({ id: "run-2", startedAt: "2026-02-13T12:00:00.000Z" }));
+		await writeCurrentRun("run-2");
+		sessionStore.upsert(makeSession({ agentName: "r2-a", id: "s-r2-1", runId: "run-2" }));
+
+		// Verify state
+		const currentRunId = await readCurrentRunFile();
+		expect(currentRunId).toBe("run-2");
+
+		const run1 = runStore.getRun("run-1");
+		expect(run1?.status).toBe("completed");
+		expect(run1?.agentCount).toBe(2);
+
+		const run2 = runStore.getRun("run-2");
+		expect(run2?.status).toBe("active");
+		expect(run2?.agentCount).toBe(1);
+
+		const allRuns = runStore.listRuns();
+		expect(allRuns).toHaveLength(2);
+	});
+});
+
+describe("edge cases", () => {
+	test("run with zero agents", () => {
+		runStore.createRun(makeRun());
+		const run = runStore.getRun("run-2026-02-13T10:00:00.000Z");
+		expect(run?.agentCount).toBe(0);
+	});
+
+	test("show run with agents from different capabilities", () => {
+		const runId = "run-2026-02-13T10:00:00.000Z";
+		runStore.createRun(makeRun());
+
+		const capabilities = ["builder", "scout", "reviewer"];
+		for (let i = 0; i < capabilities.length; i++) {
+			sessionStore.upsert(
+				makeSession({
+					agentName: `agent-${i}`,
+					id: `s-${i}`,
+					runId,
+					capability: capabilities[i] ?? "builder",
+				}),
+			);
+		}
+
+		const agents = sessionStore.getByRun(runId);
+		expect(agents).toHaveLength(3);
+		const caps = agents.map((a) => a.capability).sort();
+		expect(caps).toEqual(["builder", "reviewer", "scout"]);
+	});
+
+	test("sessions.db does not exist for list returns empty", async () => {
+		// Remove the db that was created in beforeEach
+		runStore.close();
+		sessionStore.close();
+		await rm(dbPath, { force: true });
+		// Also remove WAL/SHM files
+		await rm(`${dbPath}-wal`, { force: true });
+		await rm(`${dbPath}-shm`, { force: true });
+
+		const file = Bun.file(dbPath);
+		expect(await file.exists()).toBe(false);
+
+		// Re-create stores for afterEach cleanup
+		runStore = createRunStore(join(agentplateDir, "unused-run.db"));
+		sessionStore = createSessionStore(join(agentplateDir, "unused-session.db"));
+	});
+});