@kitlangton/motel 0.2.4 → 0.2.6

package/src/telemetry.test.ts

@@ -1,5 +1,6 @@
+import { Database } from "bun:sqlite"
 import { afterAll, beforeAll, describe, expect, it } from "bun:test"
-import { mkdtempSync, rmSync } from "node:fs"
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { Effect, References } from "effect"
@@ -8,6 +9,8 @@ import { attributeFiltersFromArgs, attributeContainsFiltersFromArgs, isAttribute
 describe("motel telemetry store", () => {
 	const tempDir = mkdtempSync(join(tmpdir(), "motel-test-"))
 	const dbPath = join(tempDir, "telemetry.sqlite")
+	const previousDatabasePath = process.env.MOTEL_OTEL_DB_PATH
+	const previousRetentionHours = process.env.MOTEL_OTEL_RETENTION_HOURS
 	let storeRuntime: Awaited<typeof import("./runtime.ts")>["storeRuntime"]
 	let TelemetryStore: Awaited<typeof import("./services/TelemetryStore.ts")>["TelemetryStore"]
 	let motelOpenApiSpec: Awaited<typeof import("./httpApi.ts")>["motelOpenApiSpec"]
@@ -23,7 +26,7 @@ describe("motel telemetry store", () => {
 		const nowNanos = BigInt(Date.now()) * 1_000_000n
 		const oneSecond = 1_000_000_000n
 
-		const ingest = Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+		const ingest = Effect.flatMap(TelemetryStore, (store) =>
 				Effect.flatMap(
 					store.ingestTraces({
 					resourceSpans: [
@@ -126,7 +129,7 @@ describe("motel telemetry store", () => {
 						},
 					],
 				}),
-			).pipe(Effect.flatMap(() => Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			).pipe(Effect.flatMap(() => Effect.flatMap(TelemetryStore, (store) =>
 				store.ingestTraces({
 					resourceSpans: [{
 						resource: { attributes: [{ key: "service.name", value: { stringValue: "test-api" } }] },
@@ -219,13 +222,192 @@ describe("motel telemetry store", () => {
 		await storeRuntime.runPromise(ingest.pipe(Effect.provideService(References.MinimumLogLevel, "None")))
 	})
 
-	afterAll(() => {
+	afterAll(async () => {
+		await storeRuntime.dispose()
 		rmSync(tempDir, { recursive: true, force: true })
+		if (previousDatabasePath === undefined) delete process.env.MOTEL_OTEL_DB_PATH
+		else process.env.MOTEL_OTEL_DB_PATH = previousDatabasePath
+		if (previousRetentionHours === undefined) delete process.env.MOTEL_OTEL_RETENTION_HOURS
+		else process.env.MOTEL_OTEL_RETENTION_HOURS = previousRetentionHours
+	})
+
+	it("creates fresh DBs with auto_vacuum=INCREMENTAL", () => {
+		// Headline regression test: PRAGMA auto_vacuum is a header-level
+		// setting that only takes effect when set BEFORE the first CREATE
+		// TABLE, or after a full VACUUM. The previous code set it AFTER
+		// schema init, so every motel DB ever created had auto_vacuum=NONE
+		// and incremental_vacuum was silently a no-op — the documented
+		// mechanism behind the 17GB telemetry.sqlite this test exists to
+		// prevent.
+		const probe = new Database(dbPath, { readonly: true })
+		try {
+			const mode = (probe.query(`PRAGMA auto_vacuum`).get() as { auto_vacuum: number }).auto_vacuum
+			expect(mode).toBe(2) // 2 = INCREMENTAL
+		} finally {
+			probe.close()
+		}
+	})
+
+	it("incremental_vacuum reclaims pages back to the OS after deletes", () => {
+		// Proves the full reclaim chain works on the real schema: DELETE
+		// → wal_checkpoint → incremental_vacuum → page_count drops. With
+		// the previous auto_vacuum=NONE bug, page_count would not change
+		// no matter how many incremental_vacuum calls were made.
+		// Operate on a copy of the seed DB so we don't destroy state that
+		// later tests rely on. Checkpoint first so the copy is consistent.
+		const sourceProbe = new Database(dbPath)
+		try { sourceProbe.exec(`PRAGMA wal_checkpoint(TRUNCATE);`) } finally { sourceProbe.close() }
+		const clonePath = join(tempDir, "telemetry-vacuum-clone.sqlite")
+		copyFileSync(dbPath, clonePath)
+		const probe = new Database(clonePath)
+		try {
+			probe.exec(`PRAGMA busy_timeout = 5000;`)
+
+			// Bulk-insert filler so we have enough pages to make truncation
+			// observable. SQLite frees pages whole-page-at-a-time, so a tiny
+			// fixture (a handful of partial pages) won't yield a measurable
+			// page_count delta. 1000 rows × ~600 bytes = ~600KB ≈ 150 pages.
+			const stmt = probe.prepare(
+				`INSERT INTO spans (trace_id, span_id, parent_span_id, service_name, scope_name, operation_name, kind, start_time_ms, end_time_ms, duration_ms, status, attributes_json, resource_json, events_json) VALUES (?, ?, NULL, 'vac', 'scope', 'op', 'INTERNAL', 0, 0, 0, 'OK', '{}', '{}', '[]')`,
+			)
+			probe.exec(`BEGIN IMMEDIATE;`)
+			const filler = "x".repeat(512)
+			for (let i = 0; i < 1000; i++) {
+				stmt.run(`v${i.toString().padStart(8, "0")}-${filler.slice(0, 40)}`, `s${i.toString(16).padStart(15, "0")}`)
+			}
+			probe.exec(`COMMIT;`)
+
+			const pageCountBefore = (probe.query(`PRAGMA page_count`).get() as { page_count: number }).page_count
+			expect(pageCountBefore).toBeGreaterThan(50)
+
+			probe.exec(`DELETE FROM spans WHERE service_name = 'vac';`)
+
+			const freelistAfterDelete = (probe.query(`PRAGMA freelist_count`).get() as { freelist_count: number }).freelist_count
+			expect(freelistAfterDelete).toBeGreaterThan(0)
+
+			probe.exec(`PRAGMA wal_checkpoint(RESTART);`)
+			probe.exec(`PRAGMA incremental_vacuum;`)
+			probe.exec(`PRAGMA wal_checkpoint(TRUNCATE);`)
+
+			const pageCountAfter = (probe.query(`PRAGMA page_count`).get() as { page_count: number }).page_count
+			const freelistAfter = (probe.query(`PRAGMA freelist_count`).get() as { freelist_count: number }).freelist_count
+			expect(pageCountAfter).toBeLessThan(pageCountBefore)
+			expect(freelistAfter).toBeLessThan(freelistAfterDelete)
+		} finally {
+			probe.close()
+		}
+	})
+
+	it("retention prunes old correlated orphan logs and preserves recent logs", async () => {
+		const oldNanos = BigInt(Date.now() - 48 * 60 * 60 * 1000) * 1_000_000n
+		const recentNanos = BigInt(Date.now()) * 1_000_000n
+		await storeRuntime.runPromise(
+			Effect.flatMap(TelemetryStore, (store) =>
+				Effect.andThen(
+					store.ingestLogs({
+						resourceLogs: [{
+							resource: { attributes: [{ key: "service.name", value: { stringValue: "retention-test" } }] },
+							scopeLogs: [{ logRecords: [{ traceId: "missing-old-trace", timeUnixNano: String(oldNanos), body: { stringValue: "expired-correlated-log" } }, { traceId: "missing-recent-trace", timeUnixNano: String(recentNanos), body: { stringValue: "recent-correlated-log" } }] }],
+						}],
+					}),
+					store.runRetentionNow,
+				),
+			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
+		)
+
+		const probe = new Database(dbPath, { readonly: true })
+		try {
+			const oldCount = (probe.query(`SELECT COUNT(*) AS c FROM logs WHERE body = 'expired-correlated-log'`).get() as { c: number }).c
+			const recentCount = (probe.query(`SELECT COUNT(*) AS c FROM logs WHERE body = 'recent-correlated-log'`).get() as { c: number }).c
+			expect(oldCount).toBe(0)
+			expect(recentCount).toBe(1)
+		} finally {
+			probe.close()
+		}
+	})
+
+	it("retention cleans orphan log indexes even when no logs are deleted", async () => {
+		const probe = new Database(dbPath)
+		try {
+			probe.query(`INSERT INTO log_attributes(log_id, key, value) VALUES (?, 'orphan', 'value')`).run(9_999_999)
+			probe.query(`INSERT INTO log_body_fts(log_id, body) VALUES (?, 'orphan body')`).run("9999999")
+		} finally {
+			probe.close()
+		}
+
+		await storeRuntime.runPromise(
+			Effect.flatMap(TelemetryStore, (store) => store.runRetentionNow).pipe(
+				Effect.provideService(References.MinimumLogLevel, "None"),
+			),
+		)
+
+		const check = new Database(dbPath, { readonly: true })
+		try {
+			expect((check.query(`SELECT COUNT(*) AS c FROM log_attributes WHERE log_id = 9999999`).get() as { c: number }).c).toBe(0)
+			expect((check.query(`SELECT COUNT(*) AS c FROM log_body_fts WHERE log_id = '9999999'`).get() as { c: number }).c).toBe(0)
+		} finally {
+			check.close()
+		}
+	})
+
+	it("does not rewrite legacy auto_vacuum databases on startup", async () => {
+		const legacyPath = join(tempDir, "legacy-no-vacuum.sqlite")
+		const legacy = new Database(legacyPath)
+		legacy.exec(`PRAGMA auto_vacuum = NONE; CREATE TABLE legacy(value TEXT); INSERT INTO legacy VALUES ('kept');`)
+		legacy.close()
+
+		const open = Bun.spawn({
+			cmd: [process.execPath, "-e", `const { Effect } = await import('effect'); const { storeRuntime } = await import('./src/runtime.ts'); const { TelemetryStore } = await import('./src/services/TelemetryStore.ts'); await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) => store.listServices)); await storeRuntime.dispose()`],
+			cwd: process.cwd(),
+			env: { ...process.env, MOTEL_OTEL_DB_PATH: legacyPath },
+			stdout: "ignore",
+			stderr: "pipe",
+		})
+		expect(await open.exited).toBe(0)
+
+		const probe = new Database(legacyPath, { readonly: true })
+		try {
+			expect((probe.query(`PRAGMA auto_vacuum`).get() as { auto_vacuum: number }).auto_vacuum).toBe(0)
+			expect((probe.query(`SELECT value FROM legacy`).get() as { value: string }).value).toBe("kept")
+		} finally {
+			probe.close()
+		}
+	})
+
+	it("incrementally backfills historical AI FTS content", async () => {
+		const historicalPath = join(tempDir, "historical-fts.sqlite")
+		const seedScript = `
+			const { Effect } = await import('effect')
+			const { storeRuntime } = await import('./src/runtime.ts')
+			const { TelemetryStore } = await import('./src/services/TelemetryStore.ts')
+			await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) => store.ingestTraces({ resourceSpans: [{ resource: { attributes: [{ key: 'service.name', value: { stringValue: 'historical-fts' } }] }, scopeSpans: [{ spans: [{ traceId: 'historical-trace', spanId: 'historical-span', name: 'ai.generateText', startTimeUnixNano: '1', endTimeUnixNano: '2', attributes: [{ key: 'ai.response.text', value: { stringValue: 'historical-backfill-token' } }] }] }] }] })))
+			await storeRuntime.dispose()
+		`
+		const seed = Bun.spawn({ cmd: [process.execPath, "-e", seedScript], cwd: process.cwd(), env: { ...process.env, MOTEL_OTEL_DB_PATH: historicalPath }, stdout: "ignore", stderr: "pipe" })
+		expect(await seed.exited).toBe(0)
+
+		const damage = new Database(historicalPath)
+		damage.query(`INSERT INTO span_attr_fts(span_attr_fts) VALUES ('delete-all')`).run()
+		damage.query(`DELETE FROM motel_maintenance WHERE key = 'span_attr_fts_v1'`).run()
+		damage.close()
+
+		const repair = Bun.spawn({ cmd: [process.execPath, "-e", `const { Effect } = await import('effect'); const { storeRuntime } = await import('./src/runtime.ts'); const { TelemetryStore } = await import('./src/services/TelemetryStore.ts'); await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) => store.listServices)); await Bun.sleep(500); await storeRuntime.dispose()`], cwd: process.cwd(), env: { ...process.env, MOTEL_OTEL_DB_PATH: historicalPath }, stdout: "ignore", stderr: "pipe" })
+		expect(await repair.exited).toBe(0)
+
+		const probe = new Database(historicalPath, { readonly: true })
+		try {
+			const match = (probe.query(`SELECT COUNT(*) AS c FROM span_attr_fts WHERE span_attr_fts MATCH 'historical'`).get() as { c: number }).c
+			const marker = (probe.query(`SELECT value FROM motel_maintenance WHERE key = 'span_attr_fts_v1'`).get() as { value: string }).value
+			expect(match).toBe(1)
+			expect(marker).toBe("complete")
+		} finally {
+			probe.close()
+		}
 	})
 
 	it("filters traces by attr.* fields", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchTraces({
 					serviceName: "test-api",
 					attributeFilters: {
@@ -242,7 +424,7 @@ describe("motel telemetry store", () => {
 
 	it("looks up a span directly by spanId", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) => store.getSpan("child-1")).pipe(
+			Effect.flatMap(TelemetryStore, (store) => store.getSpan("child-1")).pipe(
 				Effect.provideService(References.MinimumLogLevel, "None"),
 			),
 		)
@@ -253,9 +435,57 @@ describe("motel telemetry store", () => {
 		expect(result?.span.depth).toBe(1)
 	})
 
+	it("returns trace details through the query worker when spans share empty event arrays", async () => {
+		const workerDbPath = join(tempDir, "query-worker-shared-events.sqlite")
+		const script = `
+			const { Effect, ManagedRuntime } = await import("effect")
+			const { storeRuntime } = await import("./src/runtime.ts")
+			const { TelemetryStore, TelemetryStoreReadonly } = await import("./src/services/TelemetryStore.ts")
+			await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) => store.ingestTraces({
+				resourceSpans: [{
+					resource: { attributes: [{ key: "service.name", value: { stringValue: "worker-repro" } }] },
+					scopeSpans: [{ spans: [
+						{ traceId: "shared-trace", spanId: "root", name: "root", startTimeUnixNano: "1", endTimeUnixNano: "3" },
+						{ traceId: "shared-trace", spanId: "child", parentSpanId: "root", name: "child", startTimeUnixNano: "2", endTimeUnixNano: "3" },
+					] }],
+				}],
+			})))
+			await storeRuntime.dispose()
+			const { TelemetryQueryLive } = await import("./src/services/TelemetryQuery.ts")
+			const queryRuntime = ManagedRuntime.make(TelemetryQueryLive)
+			try {
+				const trace = await queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (store) => store.getTrace("shared-trace")))
+				if (trace?.spans.length !== 2) throw new Error("Expected two spans")
+			} finally {
+				await queryRuntime.dispose()
+			}
+		`
+		const child = Bun.spawn({
+			cmd: [process.execPath, "-e", script],
+			cwd: process.cwd(),
+			env: { ...process.env, MOTEL_OTEL_DB_PATH: workerDbPath },
+			stdout: "ignore",
+			stderr: "pipe",
+		})
+		const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()])
+		expect(exitCode, stderr).toBe(0)
+	})
+
+	it("uses the canonical earliest root when directly looking up a later root span", async () => {
+		const result = await storeRuntime.runPromise(
+			Effect.flatMap(TelemetryStore, (store) => store.getSpan("ai-stream-2")).pipe(
+				Effect.provideService(References.MinimumLogLevel, "None"),
+			),
+		)
+
+		expect(result?.traceId).toBe("trace-ai")
+		expect(result?.span.operationName).toBe("ai.generateText")
+		expect(result?.rootOperationName).toBe("ai.streamText")
+	})
+
 	it("filters logs by spanId", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({
 					spanId: "child-1",
 				}),
@@ -268,7 +498,7 @@ describe("motel telemetry store", () => {
 
 	it("searches spans by operation, parent operation, and attr filters", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchSpans({
 					serviceName: "test-api",
 					operation: "tool.call",
@@ -288,7 +518,7 @@ describe("motel telemetry store", () => {
 
 	it("lists spans for a trace", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) => store.listTraceSpans("trace-1")).pipe(
+			Effect.flatMap(TelemetryStore, (store) => store.listTraceSpans("trace-1")).pipe(
 				Effect.provideService(References.MinimumLogLevel, "None"),
 			),
 		)
@@ -303,7 +533,7 @@ describe("motel telemetry store", () => {
 
 	it("aggregates trace stats by operation", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.traceStats({
 					groupBy: "operation",
 					agg: "avg_duration",
@@ -321,7 +551,7 @@ describe("motel telemetry store", () => {
 
 	it("aggregates log stats by severity", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.logStats({
 					groupBy: "severity",
 					agg: "count",
@@ -347,7 +577,7 @@ describe("motel telemetry store", () => {
 
 	it("lists trace summaries without loading spans", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.listTraceSummaries(null),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -365,7 +595,7 @@ describe("motel telemetry store", () => {
 
 	it("lists trace summaries filtered by service", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.listTraceSummaries("test-api"),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -375,7 +605,7 @@ describe("motel telemetry store", () => {
 
 	it("searches trace summaries with status filter", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchTraceSummaries({
 					serviceName: "test-api",
 					status: "error",
@@ -389,7 +619,7 @@ describe("motel telemetry store", () => {
 
 	it("searches trace summaries with attribute filters", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchTraceSummaries({
 					serviceName: "test-api",
 					attributeFilters: { sessionID: "session-1" },
@@ -403,7 +633,7 @@ describe("motel telemetry store", () => {
 
 	it("searches trace summaries with operation filter", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchTraceSummaries({
 					serviceName: "test-api",
 					operation: "tool.call",
@@ -417,7 +647,7 @@ describe("motel telemetry store", () => {
 
 	it("filters logs by severity", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({ serviceName: "test-api", severity: "ERROR" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -429,7 +659,7 @@ describe("motel telemetry store", () => {
 
 	it("filters logs by severity case-insensitively", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({ serviceName: "test-api", severity: "error" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -440,7 +670,7 @@ describe("motel telemetry store", () => {
 
 	it("searches log body case-insensitively", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({ serviceName: "test-api", body: "STREAM FAILED" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -451,7 +681,7 @@ describe("motel telemetry store", () => {
 
 	it("searches spans by traceId", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchSpans({ traceId: "trace-1" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -462,7 +692,7 @@ describe("motel telemetry store", () => {
 
 	it("searches spans with attrContains substring filter", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchSpans({
 					serviceName: "test-api",
 					attributeContainsFilters: { sessionID: "session" },
@@ -476,7 +706,7 @@ describe("motel telemetry store", () => {
 
 	it("searches spans with attrContains case-insensitively", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchSpans({
 					serviceName: "test-api",
 					attributeContainsFilters: { modelID: "GPT" },
@@ -490,7 +720,7 @@ describe("motel telemetry store", () => {
 
 	it("searches logs with attrContains substring filter", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({
 					serviceName: "test-api",
 					attributeContainsFilters: { tool: "sea" },
@@ -504,7 +734,7 @@ describe("motel telemetry store", () => {
 
 	it("combines severity and body filters", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchLogs({ serviceName: "test-api", severity: "INFO", body: "tool" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -515,7 +745,7 @@ describe("motel telemetry store", () => {
 
 	it("computes facet status without N+1 queries", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.listFacets({
 					type: "traces",
 					field: "status",
@@ -532,7 +762,7 @@ describe("motel telemetry store", () => {
 
 	it("computes logStats with SQL aggregation", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.logStats({
 					groupBy: "service",
 					agg: "count",
@@ -548,7 +778,7 @@ describe("motel telemetry store", () => {
 
 	it("computes traceStats count via SQL", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.traceStats({
 					groupBy: "status",
 					agg: "count",
@@ -566,7 +796,7 @@ describe("motel telemetry store", () => {
 
 	it("computes traceStats error_rate via SQL", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.traceStats({
 					groupBy: "service",
 					agg: "error_rate",
@@ -613,7 +843,7 @@ describe("motel telemetry store", () => {
 
 	it("searches AI calls and returns compact summaries", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({}),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -636,7 +866,7 @@ describe("motel telemetry store", () => {
 
 	it("dedupes nested doStream spans from AI summaries", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ sessionId: "ses_test123" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -647,7 +877,7 @@ describe("motel telemetry store", () => {
 
 	it("filters AI calls by model", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ model: "claude-opus-4" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -659,7 +889,7 @@ describe("motel telemetry store", () => {
 
 	it("filters AI calls by sessionId", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ sessionId: "ses_test123" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -670,7 +900,7 @@ describe("motel telemetry store", () => {
 
 	it("searches AI calls by text content", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ text: "joke about programming" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -683,7 +913,7 @@ describe("motel telemetry store", () => {
 		// Verifies FTS indexes ai.response.text, not just ai.prompt*. The
 		// seeded ai-stream-2 has response "Error: rate limited".
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ text: "rate limited" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -694,7 +924,7 @@ describe("motel telemetry store", () => {
 		// unicode61 tokenizer is case-insensitive by default; prefix `*`
 		// handles partial terms like `"PROG"` matching `"programming"`.
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ text: "PROG" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -705,7 +935,7 @@ describe("motel telemetry store", () => {
 		// FTS5 treats `"`, `*`, `-`, `:` as operators; toFtsQuery must
 		// strip them so raw user input never crashes the query.
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ text: `"joke" - about:programming*` }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -714,7 +944,7 @@ describe("motel telemetry store", () => {
 
 	it("filters AI calls by operation type", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.searchAiCalls({ operation: "generateText" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -725,7 +955,7 @@ describe("motel telemetry store", () => {
 
 	it("gets AI call detail with full payloads", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.getAiCall("ai-stream-1"),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -743,7 +973,7 @@ describe("motel telemetry store", () => {
 
 	it("returns null for non-AI span in getAiCall", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.getAiCall("root-1"),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -753,7 +983,7 @@ describe("motel telemetry store", () => {
 
 	it("aggregates AI call stats by model", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.aiCallStats({ groupBy: "model", agg: "count" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -767,7 +997,7 @@ describe("motel telemetry store", () => {
 
 	it("aggregates AI call stats by status", async () => {
 		const result = await storeRuntime.runPromise(
-			Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+			Effect.flatMap(TelemetryStore, (store) =>
 				store.aiCallStats({ groupBy: "status", agg: "count" }),
 			).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
 		)
@@ -784,4 +1014,40 @@ describe("motel telemetry store", () => {
 		expect(motelOpenApiSpec.paths["/api/ai/calls/{spanId}"]).toBeDefined()
 		expect(motelOpenApiSpec.paths["/api/ai/stats"]).toBeDefined()
 	})
+
+	it("lists services with recent child-span activity even when the root started earlier", async () => {
+		const nowNanos = BigInt(Date.now()) * 1_000_000n
+		const oldRootNanos = nowNanos - 2n * 24n * 60n * 60n * 1_000_000_000n
+		await storeRuntime.runPromise(
+			Effect.flatMap(TelemetryStore, (store) => store.ingestTraces({
+				resourceSpans: [{
+					resource: { attributes: [{ key: "service.name", value: { stringValue: "active-child-only" } }] },
+					scopeSpans: [{
+						spans: [{
+							traceId: "trace-active-child",
+							spanId: "old-root",
+							name: "old.root",
+							startTimeUnixNano: String(oldRootNanos),
+							endTimeUnixNano: String(oldRootNanos + 1_000_000n),
+						}, {
+							traceId: "trace-active-child",
+							spanId: "recent-child",
+							parentSpanId: "old-root",
+							name: "recent.child",
+							startTimeUnixNano: String(nowNanos),
+							endTimeUnixNano: String(nowNanos + 1_000_000n),
+						}],
+					}],
+				}],
+			})).pipe(Effect.provideService(References.MinimumLogLevel, "None")),
+		)
+
+		const services = await storeRuntime.runPromise(
+			Effect.flatMap(TelemetryStore, (store) => store.listServices).pipe(
+				Effect.provideService(References.MinimumLogLevel, "None"),
+			),
+		)
+
+		expect(services).toContain("active-child-only")
+	})
 })

package/src/ui/AiChatView.tsx

@@ -11,7 +11,7 @@ import {
 } from "./aiChatModel.ts"
 import { formatDuration, truncateText } from "./format.ts"
 import { AlignedHeaderLine, BlankRow, Divider, PlainLine, TextLine } from "./primitives.tsx"
-import type { AiCallDetailState } from "./state.ts"
+import type { AiCallDetailState } from "./aiState.ts"
 import { colors, SEPARATOR } from "./theme.ts"
 
 export const AI_CHAT_HEADER_ROWS = 4

package/src/ui/AttrFilterModal.tsx

@@ -2,7 +2,7 @@ import { RGBA, TextAttributes } from "@opentui/core"
 import { BlankRow, TextLine } from "./primitives.tsx"
 import { colors } from "./theme.ts"
 import { fitCell, truncateText } from "./format.ts"
-import type { AttrFacetState, AttrPickerMode } from "./state.ts"
+import type { AttrFacetState, AttrPickerMode } from "./atoms.ts"
 
 export interface AttrFilterModalProps {
 	readonly width: number