@kitlangton/motel 0.1.3 → 0.2.1

package/src/daemon.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs"
 import { promises as fsp } from "node:fs"
 import * as path from "node:path"
 import { Effect } from "effect"
-import { listAliveEntries, MOTEL_SERVICE_ID, type RegistryEntry, isAlive } from "./registry.js"
+import { isAlive, listAliveEntries, MOTEL_SERVICE_ID, type RegistryEntry } from "./registry.js"
 
 const DEFAULT_REPO_ROOT = path.resolve(import.meta.dir, "..")
 const DEFAULT_RUNTIME_DIR = path.join(DEFAULT_REPO_ROOT, ".motel-data")
@@ -13,6 +13,18 @@ const START_TIMEOUT_MS = 15_000
 const STOP_TIMEOUT_MS = 10_000
 const LOCK_TIMEOUT_MS = 10_000
 const POLL_INTERVAL_MS = 150
+/** Fast probe used inside the waitForHealthy poll loop — we call it
+ *  every POLL_INTERVAL_MS, so a generous budget would stall the loop. */
+const HEALTH_FAST_TIMEOUT_MS = 750
+/** Patient probe used on critical paths: the first getStatus() call
+ *  in ensure(), and the final pre-throw check after a spawned child
+ *  dies. A real daemon with a busy SQLite writer (FTS backfill, big
+ *  DB) can easily take 1-2s to answer /api/health — if we declare
+ *  the port empty at 750ms we'll spawn a duplicate and collide with
+ *  EADDRINUSE. 3s is long enough to tolerate a slow healthy daemon
+ *  and short enough that a truly-down daemon is still detected
+ *  before START_TIMEOUT_MS fires. */
+const HEALTH_PATIENT_TIMEOUT_MS = 3_000
 
 type HealthShape = {
 	readonly ok: boolean
@@ -134,9 +146,9 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 	const config = resolveConfig(options)
 	const mapError = (error: unknown) => new DaemonError(error instanceof Error ? error.message : String(error))
 
-	const fetchHealth = async (): Promise<HealthShape | null> => {
+	const fetchHealth = async (timeoutMs: number = HEALTH_FAST_TIMEOUT_MS): Promise<HealthShape | null> => {
 		try {
-			const response = await fetch(`${config.baseUrl}/api/health`, { signal: AbortSignal.timeout(750) })
+			const response = await fetch(`${config.baseUrl}/api/health`, { signal: AbortSignal.timeout(timeoutMs) })
 			if (!response.ok) return null
 			return await response.json() as HealthShape
 		} catch {
@@ -157,6 +169,62 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		return null
 	}
 
+	/**
+	 * Mismatch check against a registry entry — mirrors describeManagedMismatch
+	 * but drives off the registry file instead of an HTTP health response.
+	 * Used on the fast path in getStatus so warm-start doesn't need to wait
+	 * on an HTTP round-trip that may queue behind heavy OTLP ingest.
+	 *
+	 * The service-id check is implicit: any entry living in the motel
+	 * registry dir is by construction a motel daemon. databasePath is
+	 * optional for back-compat with entries written by older builds;
+	 * when absent we skip the DB check rather than refusing to adopt.
+	 */
+	const describeRegistryMismatch = (entry: RegistryEntry): string | null => {
+		if (!cwdMatches(entry.workdir)) {
+			return `Port ${config.port} is serving motel for ${entry.workdir}, not ${process.cwd()}.`
+		}
+		if (entry.databasePath && entry.databasePath !== config.databasePath) {
+			return `Port ${config.port} is serving motel with ${entry.databasePath}, expected ${config.databasePath}.`
+		}
+		return null
+	}
+
+	/**
+	 * Build a DaemonStatus from a live registry entry. Returns null when
+	 * there's no entry for our cwd, the registered pid isn't running, or
+	 * the entry is for a differently-configured daemon (different port).
+	 * This is the fast path: no HTTP, no event-loop round-trip, just a
+	 * directory read and a process.kill(pid, 0) liveness probe.
+	 */
+	const getStatusFromRegistry = (): DaemonStatus | null => {
+		const entry = readRegistryEntry()
+		if (!entry) return null
+		// Port discriminator: a motel registry shared across several
+		// daemons (e.g., user running two instances on different
+		// ports from the same workdir, or a test harness on a random
+		// port) would otherwise have us adopt an unrelated daemon.
+		// URL match is a fast, unambiguous identity check.
+		if (entry.url !== config.baseUrl) return null
+		const mismatch = describeRegistryMismatch(entry)
+		return {
+			running: mismatch === null,
+			managed: mismatch === null,
+			service: MOTEL_SERVICE_ID,
+			pid: entry.pid,
+			url: entry.url,
+			databasePath: entry.databasePath ?? config.databasePath,
+			workdir: entry.workdir,
+			startedAt: entry.startedAt,
+			version: entry.version,
+			sameWorkdir: cwdMatches(entry.workdir),
+			reason: mismatch,
+			logPath: config.logPath,
+			lockPath: config.lockPath,
+			registryPid: entry.pid,
+		}
+	}
+
 	const readLock = async (): Promise<LockShape | null> => {
 		try {
 			const raw = await fsp.readFile(config.lockPath, "utf8")
@@ -218,6 +286,17 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				throw new Error(mismatch)
 			}
 			if (!isAlive(pid)) {
+				// The spawned child is gone. Before declaring failure,
+				// do one patient probe: the child may have died from
+				// EADDRINUSE because another healthy motel is alive on
+				// the port but was answering /api/health too slowly for
+				// our fast poll. If that's the case, adopt it.
+				const patient = await fetchHealth(HEALTH_PATIENT_TIMEOUT_MS)
+				if (patient) {
+					const mismatch = describeManagedMismatch(patient)
+					if (!mismatch) return patient
+					throw new Error(mismatch)
+				}
 				throw new Error(`Daemon process ${pid} exited before becoming healthy. See ${config.logPath}.`)
 			}
 			await sleep(POLL_INTERVAL_MS)
@@ -244,9 +323,24 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		throw new Error(`Timed out waiting for daemon ${pid} to stop.`)
 	}
 
-	const getStatus = async (): Promise<DaemonStatus> => {
+	const getStatus = async (timeoutMs: number = HEALTH_FAST_TIMEOUT_MS): Promise<DaemonStatus> => {
+		// Fast path: trust the local filesystem registry. When a motel
+		// daemon started on this machine it wrote an entry for its pid
+		// + cwd + databasePath; if that entry is still there and the pid
+		// is alive, the daemon is almost certainly the one we want to
+		// adopt. HTTP health is skipped because the daemon's health
+		// endpoint can queue behind heavy OTLP ingest traffic, making
+		// the probe unreliable exactly when the daemon is busy.
+		const registryStatus = getStatusFromRegistry()
+		if (registryStatus) return registryStatus
+
+		// No local evidence → fall back to HTTP. Covers the edge cases
+		// where: a motel daemon is running but was started before this
+		// registry-first path shipped; OR the port is held by something
+		// entirely unrelated (the mismatch check turns that into a
+		// human-readable reason).
 		const registry = readRegistryEntry()
-		const health = await fetchHealth()
+		const health = await fetchHealth(timeoutMs)
 		if (!health) {
 			return {
 				running: false,
@@ -286,7 +380,11 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 	}
 
 	const ensure = async (): Promise<DaemonStatus> => {
-		const existing = await getStatus()
+		// Use the patient timeout for the initial probe — this is the
+		// critical "is there already a daemon here?" check. A false
+		// negative here drops us into the spawn path and collides with
+		// any slow-but-healthy daemon sitting on the port.
+		const existing = await getStatus(HEALTH_PATIENT_TIMEOUT_MS)
 		if (existing.managed && existing.running) return existing
 		if (existing.service !== null && existing.reason) {
 			throw new Error(existing.reason)
@@ -295,7 +393,11 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		const lock = await acquireStartupLock()
 		let spawnedPid: number | null = null
 		try {
-			const rechecked = await getStatus()
+			// Same reasoning for the post-lock re-check: another ensure()
+			// may have spawned a daemon between our first probe and the
+			// lock grant, and its initial health response can be slow
+			// while the runtime warms up.
+			const rechecked = await getStatus(HEALTH_PATIENT_TIMEOUT_MS)
 			if (rechecked.managed && rechecked.running) return rechecked
 			if (rechecked.service !== null && rechecked.reason) {
 				throw new Error(rechecked.reason)
@@ -371,7 +473,10 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		}),
 		getStatus: Effect.fn("DaemonManager.getStatus")(() =>
 			Effect.tryPromise({
-				try: getStatus,
+				// Wrapped so Effect.tryPromise only sees the no-arg call
+				// signature — the optional timeoutMs parameter is an
+				// internal detail used by ensure()'s critical probes.
+				try: () => getStatus(),
 				catch: mapError,
 			}),
 		)(),

package/src/domain.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test"
+import { AI_FTS_KEYS, isAiSpan } from "./domain.ts"
+
+describe("isAiSpan", () => {
+	test("returns false for empty tags", () => {
+		expect(isAiSpan({})).toBe(false)
+	})
+
+	test("returns false when no AI key is present", () => {
+		expect(isAiSpan({
+			"service.name": "web",
+			"http.method": "GET",
+			"db.statement": "SELECT 1",
+		})).toBe(false)
+	})
+
+	test("detects Vercel AI SDK keys", () => {
+		expect(isAiSpan({ "ai.prompt.messages": "[]" })).toBe(true)
+		expect(isAiSpan({ "ai.response.text": "hi" })).toBe(true)
+		expect(isAiSpan({ "ai.toolCall.args": "{}" })).toBe(true)
+	})
+
+	test("detects OpenTelemetry gen_ai semconv keys", () => {
+		expect(isAiSpan({ "gen_ai.prompt": "foo" })).toBe(true)
+		expect(isAiSpan({ "gen_ai.input.messages": "[]" })).toBe(true)
+		expect(isAiSpan({ "gen_ai.tool.definitions": "[]" })).toBe(true)
+	})
+
+	test("detects OpenInference keys", () => {
+		expect(isAiSpan({ "input.value": "hi" })).toBe(true)
+		expect(isAiSpan({ "output.value": "hi" })).toBe(true)
+	})
+
+	test("detects a single AI key among many non-AI keys", () => {
+		expect(isAiSpan({
+			"service.name": "web",
+			"http.method": "POST",
+			"http.status_code": "200",
+			"ai.model.id": "ignored-not-in-fts-keys",
+			"ai.prompt": "tell me a joke",
+		})).toBe(true)
+	})
+
+	test("ignores AI-adjacent keys that are not in the FTS set", () => {
+		// `ai.model.provider`, `ai.settings.*`, `ai.telemetry.*` carry
+		// metadata, not content, so they intentionally aren't part of
+		// AI_FTS_KEYS. A span with ONLY those should not be flagged.
+		expect(isAiSpan({
+			"ai.model.provider": "openai",
+			"ai.model.id": "gpt-4",
+			"ai.settings.maxRetries": "2",
+		})).toBe(false)
+	})
+
+	test("every documented key triggers detection", () => {
+		// Guard against a future reshuffle of AI_FTS_KEYS that might
+		// drop a key silently — every declared key should round-trip.
+		for (const key of AI_FTS_KEYS) {
+			expect(isAiSpan({ [key]: "payload" })).toBe(true)
+		}
+	})
+})

package/src/domain.ts

@@ -145,14 +145,72 @@ export const AI_ATTR_MAP = {
 	responseTimestamp: "ai.response.timestamp",
 } as const
 
-/** Attribute keys to search across when using the `text` filter */
-export const AI_TEXT_SEARCH_KEYS = [
-	"ai.prompt.messages",
+/**
+ * Attribute keys that carry LLM prompt/response content and should be
+ * indexed in the span-attribute FTS table. These are the keys emitted by
+ * well-known LLM instrumentation conventions:
+ *
+ * - **Vercel AI SDK** (`ai.*`): rich, SDK-specific attributes captured by
+ *   `experimental_telemetry` on `generateText` / `streamText` / `generateObject`.
+ * - **OpenTelemetry GenAI semantic conventions** (`gen_ai.*`): the
+ *   cross-vendor standard. The singular `prompt`/`completion` attrs are
+ *   deprecated in favor of event-based capture but are still emitted by
+ *   most instrumentations, so we keep them.
+ * - **OpenInference** (`input.value` / `output.value`): Arize Phoenix /
+ *   LangChain-style normalized input/output.
+ *
+ * Keys here trigger FTS indexing on insert via a trigger in TelemetryStore.
+ * Adding a key requires a one-time backfill; removing one leaves orphan
+ * FTS entries that get cleaned up on next retention pass.
+ */
+export const AI_FTS_KEYS = [
+	// Vercel AI SDK
 	"ai.prompt",
-	"ai.response.text",
+	"ai.prompt.messages",
 	"ai.prompt.tools",
+	"ai.prompt.toolChoice",
+	"ai.response.text",
+	"ai.response.toolCalls",
+	"ai.response.reasoning",
+	"ai.response.object",
+	"ai.toolCall.args",
+	"ai.toolCall.result",
+	// OpenTelemetry GenAI semantic conventions
+	"gen_ai.prompt",
+	"gen_ai.completion",
+	"gen_ai.input.messages",
+	"gen_ai.output.messages",
+	"gen_ai.system_instructions",
+	"gen_ai.tool.definitions",
+	"gen_ai.tool.message.content",
+	// OpenInference (Phoenix, LangChain, etc.)
+	"input.value",
+	"output.value",
 ] as const
 
+/**
+ * Back-compat alias. The `text` filter on `/api/ai/calls` historically
+ * LIKE-searched these four keys; now FTS indexes the broader AI_FTS_KEYS
+ * set so the filter transparently covers more content.
+ */
+export const AI_TEXT_SEARCH_KEYS = AI_FTS_KEYS
+
+/**
+ * True if a span's tags contain any of the AI content keys we track.
+ * Used as the single source of truth for "this span has LLM payloads
+ * worth a specialized view" — drives the ✦ marker in the waterfall row
+ * and picks the chat-flavored renderer when the user drills into the
+ * span's detail. Scanning happens once per row during render so this
+ * needs to stay O(AI_FTS_KEYS.length) with cheap `in` checks rather
+ * than an `Object.keys(...).some(...)` allocation.
+ */
+export const isAiSpan = (tags: Readonly<Record<string, string>>): boolean => {
+	for (const key of AI_FTS_KEYS) {
+		if (key in tags) return true
+	}
+	return false
+}
+
 const PREVIEW_LENGTH = 200
 
 export const truncatePreview = (value: string | null | undefined): string | null => {

package/src/httpApi.ts

@@ -121,6 +121,9 @@ export const MotelHttpApi = HttpApi.make("MotelTelemetry")
 						minDurationMs: Schema.optionalKey(Schema.Number).pipe(
 							Schema.annotateKey({ description: "Only return traces slower than this threshold (milliseconds)" }),
 						),
+						aiText: Schema.optionalKey(Schema.String).pipe(
+							Schema.annotateKey({ description: "FTS match against AI prompt/response/tool content across all spans in the trace. Tokens are prefix-matched and implicitly AND'd." }),
+						),
 						lookback: LookbackParam,
 						limit: LimitParam,
 						cursor: CursorParam,
@@ -128,7 +131,7 @@ export const MotelHttpApi = HttpApi.make("MotelTelemetry")
 					success: TraceSummaryList,
 				})
 					.annotate(OpenApi.Summary, "Search traces with filters")
-					.annotate(OpenApi.Description, "Search compact trace summaries with filters. Use /api/traces/{traceId} for full details. Supports cursor pagination and attr.<key> filters in the query string."),
+					.annotate(OpenApi.Description, "Search compact trace summaries with filters. Use /api/traces/{traceId} for full details. Supports cursor pagination, attr.<key> filters in the query string, and aiText for full-text search across LLM prompt/response content."),
 
 				HttpApiEndpoint.get("traceStats", "/api/traces/stats", {
 					query: {

package/src/localServer.ts

@@ -1,18 +1,27 @@
 import { promises as fs } from "node:fs"
 import path from "node:path"
-import { Effect, Layer, Context } from "effect"
-import { config, parsePositiveInt, resolveOtelUrl } from "./config.js"
+import { Effect, Layer } from "effect"
+import { config, parsePositiveInt } from "./config.js"
 import { HttpApiBuilder, HttpApiScalar } from "effect/unstable/httpapi"
+import * as HttpMiddleware from "effect/unstable/http/HttpMiddleware"
 import * as HttpRouter from "effect/unstable/http/HttpRouter"
-import * as HttpServer from "effect/unstable/http/HttpServer"
 import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"
+import * as HttpStaticServer from "effect/unstable/http/HttpStaticServer"
+import * as BunHttpServer from "@effect/platform-bun/BunHttpServer"
 import { MotelHttpApi } from "./httpApi.js"
 import { attributeFiltersFromEntries, attributeContainsFiltersFromEntries, ATTRIBUTE_FILTER_PREFIX, ATTRIBUTE_CONTAINS_PREFIX } from "./queryFilters.js"
-import { MOTEL_SERVICE_ID, MOTEL_VERSION, writeRegistryEntry } from "./registry.js"
+import { MOTEL_SERVICE_ID, MOTEL_VERSION, removeRegistryEntry, writeRegistryEntry } from "./registry.js"
+import { AsyncIngest, AsyncIngestLive } from "./services/AsyncIngest.js"
 import { TelemetryStore, TelemetryStoreLive } from "./services/TelemetryStore.js"
 import type { LogItem, TraceItem, TraceSummaryItem } from "./domain.js"
 import { lifecycleLabel } from "./ui/format.js"
 
+// Set by the RegistryLayer acquisition once the Bun socket has bound.
+// Both /api/health and the registry entry read from here so they agree
+// on a single server-start timestamp, and the value reflects actual
+// listen time rather than module-evaluation time.
+let serverStartedAt: string = new Date(0).toISOString()
+
 const TRACE_DEFAULT_LIMIT = 20
 const TRACE_MAX_LIMIT = 100
 const TRACE_DEFAULT_LOOKBACK = 60
@@ -24,28 +33,21 @@ const LOG_MAX_LIMIT = 500
 const LOG_DEFAULT_LOOKBACK = 60
 const LOG_MAX_LOOKBACK = 24 * 60
 
-let server: ReturnType<typeof Bun.serve> | null = null
-let disposeWebHandler: (() => Promise<void>) | null = null
-let startedAt: string | null = null
-
-const resolveBoundUrl = () => {
-	if (!server) return config.otel.queryUrl
-	const host = server.hostname === "0.0.0.0" || server.hostname === "::" ? "127.0.0.1" : server.hostname
-	return `http://${host}:${server.port}`
-}
-
 const jsonResponse = (value: unknown, status = 200) => HttpServerResponse.jsonUnsafe(value, { status })
 const textResponse = (value: string) => HttpServerResponse.text(value)
 const htmlResponse = (value: string) => HttpServerResponse.html(value)
 const notFoundResponse = (message = "Not found") => jsonResponse({ error: message }, 404)
 const requestUrl = (request: { readonly url: string }) => new URL(request.url, config.otel.baseUrl)
 const withStore = <A>(f: (store: TelemetryStore["Service"]) => Effect.Effect<A, Error>) => Effect.flatMap(TelemetryStore.asEffect(), f)
-const respondJson = <A>(effect: Effect.Effect<A, unknown, TelemetryStore>) =>
+// Response-building helpers are generic in R so a handler can depend
+// on TelemetryStore (query path) or AsyncIngest (worker-RPC path)
+// without forcing every handler onto the same service surface.
+const respondJson = <A, R>(effect: Effect.Effect<A, unknown, R>) =>
 	Effect.match(effect, {
 		onFailure: (error) => jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 500),
 		onSuccess: (value) => jsonResponse(value),
 	})
-const respondRaw = (effect: Effect.Effect<ReturnType<typeof jsonResponse>, unknown, TelemetryStore>) =>
+const respondRaw = <R>(effect: Effect.Effect<ReturnType<typeof jsonResponse>, unknown, R>) =>
 	Effect.match(effect, {
 		onFailure: (error) => jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 500),
 		onSuccess: (value) => value,
@@ -284,23 +286,33 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					service: MOTEL_SERVICE_ID,
 					databasePath: config.otel.databasePath,
 					pid: process.pid,
-					url: resolveBoundUrl(),
+					url: config.otel.baseUrl,
 					workdir: process.cwd(),
-					startedAt: startedAt ?? new Date(0).toISOString(),
+					startedAt: serverStartedAt,
 					version: MOTEL_VERSION,
 				}),
 			)
+			// OTLP ingest is routed to the worker thread via AsyncIngest
+			// so the main event loop stays free during heavy SQLite writes.
+			// Everything else still uses the direct TelemetryStore — reads
+			// are fast enough that IPC overhead isn't worth paying.
 			.handleRaw("ingestTraces", ({ request }) =>
 				respondRaw(
 					Effect.flatMap(request.json, (payload) =>
-						Effect.map(withStore((store) => store.ingestTraces(payload as any)), (result) => jsonResponse(result)),
+						Effect.map(
+							Effect.flatMap(AsyncIngest.asEffect(), (ingest) => ingest.ingestTraces({ payload })),
+							(result) => jsonResponse(result),
+						),
 					),
 				),
 			)
 			.handleRaw("ingestLogs", ({ request }) =>
 				respondRaw(
 					Effect.flatMap(request.json, (payload) =>
-						Effect.map(withStore((store) => store.ingestLogs(payload as any)), (result) => jsonResponse(result)),
+						Effect.map(
+							Effect.flatMap(AsyncIngest.asEffect(), (ingest) => ingest.ingestLogs({ payload })),
+							(result) => jsonResponse(result),
+						),
 					),
 				),
 			)
@@ -335,6 +347,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 							status: (url.searchParams.get("status") as "ok" | "error" | null) ?? null,
 							minDurationMs: url.searchParams.get("minDurationMs") ? Number.parseFloat(url.searchParams.get("minDurationMs") ?? "") : null,
 							attributeFilters,
+							aiText: url.searchParams.get("aiText"),
 							limit: limit + 1,
 							lookbackMinutes,
 							cursorStartedAtMs: cursor?.kind === "trace" ? cursor.startedAt : undefined,
@@ -586,115 +599,93 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 			),
 )
 
-const ApiLive = Layer.provideMerge(
-	HttpApiBuilder.layer(MotelHttpApi, { openapiPath: "/openapi.json" }).pipe(
-		Layer.provide(TelemetryGroupLive),
-		Layer.provide(HttpApiScalar.layer(MotelHttpApi, { scalar: { forceDarkModeState: "dark", showOperationId: true } })),
-		Layer.provide(HttpServer.layerServices),
-	),
-	TelemetryStoreLive,
-)
-
 // ---------------------------------------------------------------------------
-// Static file serving for the web UI
+// App layer: HTTP router + static SPA + telemetry store
 // ---------------------------------------------------------------------------
 
-const WEB_DIST_DIR = path.resolve(import.meta.dir, "../web/dist")
-// Only cache `true` — a `false` result is rechecked so a later `web:build` is picked up
-let webUiAvailable = false
-
-const isWebUiAvailable = async (): Promise<boolean> => {
-	if (webUiAvailable) return true
-	try {
-		webUiAvailable = await Bun.file(path.join(WEB_DIST_DIR, "index.html")).exists()
-	} catch {
-		/* ignore */
-	}
-	return webUiAvailable
-}
-
-/** Routes that must always go through the Effect API handler */
-const isStrictApiRoute = (pathname: string) =>
-	pathname.startsWith("/api/") ||
-	pathname.startsWith("/v1/") ||
-	pathname === "/openapi.json" ||
-	pathname === "/docs"
-
-const serveWebUi = async (request: Request, apiHandler: (req: Request) => Promise<Response>): Promise<Response> => {
-	const url = new URL(request.url)
-	const pathname = url.pathname
-
-	// Strict API routes always go through the Effect handler
-	if (isStrictApiRoute(pathname)) return apiHandler(request)
-
-	// Only serve web UI if built
-	if (!(await isWebUiAvailable())) return apiHandler(request)
+// API routes come from the Effect HttpApi definition. Everything under
+// /api/*, /v1/*, /openapi.json, /docs is handled here.
+const ApiLayer = HttpApiBuilder.layer(MotelHttpApi, { openapiPath: "/openapi.json" }).pipe(
+	Layer.provide(TelemetryGroupLive),
+	Layer.provide(HttpApiScalar.layer(MotelHttpApi, { scalar: { forceDarkModeState: "dark", showOperationId: true } })),
+)
 
-	// Try to serve a static file from web/dist/ (hashed assets, favicon, etc.)
-	if (pathname.startsWith("/assets/") || (pathname !== "/" && pathname.includes("."))) {
-		const resolved = path.resolve(WEB_DIST_DIR, pathname.slice(1))
-		if (resolved.startsWith(WEB_DIST_DIR) && await Bun.file(resolved).exists()) {
-			return new Response(Bun.file(resolved))
-		}
-	}
+// Web UI: Vite-built SPA served from web/dist. HttpStaticServer.layer
+// handles GET /*, filesystem lookup under `root`, and SPA fallback to
+// index.html for unknown paths — replacing the hand-rolled serveWebUi
+// wrapper that previously lived inline with Bun.serve. The API routes
+// above take precedence because HttpApi registers specific paths that
+// the router matches before falling through to the /* catch-all.
+const WEB_DIST_DIR = path.resolve(import.meta.dir, "../web/dist")
+const StaticLayer = HttpStaticServer.layer({
+	root: WEB_DIST_DIR,
+	spa: true,
+})
 
-	// SPA fallback: serve index.html for / and all client routes
-	return new Response(Bun.file(path.join(WEB_DIST_DIR, "index.html")), {
-		headers: { "content-type": "text/html; charset=utf-8" },
-	})
-}
+// Registry-entry writer as a scoped acquisition. The entry is published
+// after BunHttpServer.layer binds the socket (scope acquisition order)
+// and removed on scope release, so a bind failure never leaves a zombie
+// entry and a graceful shutdown cleans up alongside the server stop —
+// both in the same finalizer chain managed by Layer.launch.
+const RegistryLayer = Layer.effectDiscard(
+	Effect.acquireRelease(
+		Effect.sync(() => {
+			serverStartedAt = new Date().toISOString()
+			try {
+				writeRegistryEntry({
+					pid: process.pid,
+					url: config.otel.baseUrl,
+					workdir: process.cwd(),
+					startedAt: serverStartedAt,
+					version: MOTEL_VERSION,
+					databasePath: config.otel.databasePath,
+				})
+			} catch (err) {
+				console.warn(`motel: failed to write registry entry: ${(err as Error).message}`)
+			}
+		}),
+		() => Effect.sync(() => removeRegistryEntry(process.pid)),
+	),
+)
 
 // ---------------------------------------------------------------------------
 // Server lifecycle
 // ---------------------------------------------------------------------------
 
-export const startLocalServer = async () => {
-	if (server) return server
-	const { handler, dispose } = HttpRouter.toWebHandler(ApiLive, { disableLogger: true })
-	disposeWebHandler = dispose
-	server = Bun.serve({
-		hostname: config.otel.host,
+/**
+ * Launchable server layer. Composes the API + static UI + store + registry,
+ * wraps the whole stack in HttpMiddleware.tracer (per-request OTel spans
+ * with http.method / url / status / user-agent attributes), and binds the
+ * socket via @effect/platform-bun's BunHttpServer. Use from server.ts:
+ *
+ *   await Effect.runPromise(Layer.launch(ServerLive))
+ *
+ * Socket lifecycle, graceful shutdown, and error propagation are managed
+ * by the BunHttpServer layer's Scope — no hand-rolled start/stop plumbing.
+ * `reusePort: true` is retained as defense-in-depth against TIME_WAIT
+ * rebind conflicts (the registry-based adoption path in daemon.ts is the
+ * primary protection, but this covers a raw `bun src/server.ts` restart).
+ */
+export const ServerLive = HttpRouter.serve(
+	Layer.mergeAll(ApiLayer, StaticLayer, RegistryLayer),
+	{ middleware: HttpMiddleware.tracer },
+).pipe(
+	// OTLP ingest paths are NOT traced by the middleware, otherwise
+	// MOTEL_OTEL_ENABLED creates a feedback loop: every outbound span
+	// POSTs to /v1/traces, the tracer emits a span for that POST, which
+	// POSTs again on the next flush. This also shaves ~1 KB of header
+	// attributes off every ingest request that would have been written
+	// to the spans table as noise.
+	Layer.provide(HttpMiddleware.layerTracerDisabledForUrls(["/v1/traces", "/v1/logs"])),
+	// AsyncIngest spawns the telemetry worker — keeps the main-thread
+	// event loop free during heavy SQLite writes. Provided alongside
+	// the direct TelemetryStore so query handlers can still resolve
+	// their dependency directly.
+	Layer.provideMerge(AsyncIngestLive),
+	Layer.provideMerge(TelemetryStoreLive),
+	Layer.provideMerge(BunHttpServer.layer({
 		port: config.otel.port,
-		fetch(request) {
-			return serveWebUi(request, handler)
-		},
-	})
-	startedAt = new Date().toISOString()
-	try {
-		writeRegistryEntry({
-			pid: process.pid,
-			url: resolveBoundUrl(),
-			workdir: process.cwd(),
-			startedAt,
-			version: MOTEL_VERSION,
-		})
-	} catch (err) {
-		console.warn(`motel: failed to write registry entry: ${(err as Error).message}`)
-	}
-	return server
-}
-
-export const ensureLocalServer = async () => {
-	if (server) return server
-	try {
-		const response = await fetch(resolveOtelUrl("/api/health"), { signal: AbortSignal.timeout(250) })
-		if (response.ok) return null
-	} catch {
-		// Start local server below.
-	}
-	return await startLocalServer()
-}
-
-export const stopLocalServer = () => {
-	server?.stop(true)
-	server = null
-	startedAt = null
-
-	const dispose = disposeWebHandler
-	disposeWebHandler = null
-	if (dispose) {
-		void dispose().catch((err) => {
-			console.warn(`motel: failed to dispose web handler: ${(err as Error).message}`)
-		})
-	}
-}
+		hostname: config.otel.host,
+		reusePort: true,
+	})),
+)