@kitlangton/motel 0.2.1 → 0.2.5

package/src/daemon.ts

@@ -2,16 +2,15 @@ import * as fs from "node:fs"
 import { promises as fsp } from "node:fs"
 import * as path from "node:path"
 import { Effect } from "effect"
-import { isAlive, listAliveEntries, MOTEL_SERVICE_ID, type RegistryEntry } from "./registry.js"
+import { isAlive, listAliveEntries, MOTEL_SERVICE_ID, MOTEL_VERSION, 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")
-const DEFAULT_DATABASE_PATH = path.join(DEFAULT_RUNTIME_DIR, "telemetry.sqlite")
 const DEFAULT_HOST = "127.0.0.1"
 const DEFAULT_PORT = 27686
-const START_TIMEOUT_MS = 15_000
+const START_TIMEOUT_MS = 30_000
 const STOP_TIMEOUT_MS = 10_000
 const LOCK_TIMEOUT_MS = 10_000
+const START_POLL_INTERVAL_MS = 25
 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. */
@@ -44,6 +43,8 @@ type LockShape = {
 
 type DaemonConfig = {
 	readonly repoRoot: string
+	readonly serverEntry: string
+	readonly workdir: string
 	readonly runtimeDir: string
 	readonly databasePath: string
 	readonly logPath: string
@@ -79,6 +80,7 @@ export type DaemonManager = {
 
 type DaemonOptions = {
 	readonly repoRoot?: string
+	readonly workdir?: string
 	readonly runtimeDir?: string
 	readonly databasePath?: string
 	readonly host?: string
@@ -96,12 +98,15 @@ const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
 const resolveConfig = (options: DaemonOptions = {}): DaemonConfig => {
 	const repoRoot = path.resolve(options.repoRoot ?? DEFAULT_REPO_ROOT)
-	const runtimeDir = path.resolve(options.runtimeDir ?? DEFAULT_RUNTIME_DIR)
+	const workdir = path.resolve(options.workdir ?? process.cwd())
+	const runtimeDir = path.resolve(options.runtimeDir ?? path.join(workdir, ".motel-data"))
 	const databasePath = path.resolve(options.databasePath ?? path.join(runtimeDir, "telemetry.sqlite"))
 	const host = options.host ?? DEFAULT_HOST
 	const port = options.port ?? DEFAULT_PORT
 	return {
 		repoRoot,
+		serverEntry: path.join(repoRoot, "src/server.ts"),
+		workdir,
 		runtimeDir,
 		databasePath,
 		logPath: path.join(runtimeDir, "daemon.log"),
@@ -112,16 +117,14 @@ const resolveConfig = (options: DaemonOptions = {}): DaemonConfig => {
 	}
 }
 
-const cwdMatches = (workdir: string) => {
-	const cwd = process.cwd()
-	const normalizedCwd = cwd.endsWith(path.sep) ? cwd : `${cwd}${path.sep}`
-	const normalizedWorkdir = workdir.endsWith(path.sep) ? workdir : `${workdir}${path.sep}`
-	return normalizedCwd === normalizedWorkdir || normalizedCwd.startsWith(normalizedWorkdir)
+const workdirMatches = (targetWorkdir: string, daemonWorkdir: string) => {
+	const normalizedTarget = targetWorkdir.endsWith(path.sep) ? targetWorkdir : `${targetWorkdir}${path.sep}`
+	const normalizedDaemon = daemonWorkdir.endsWith(path.sep) ? daemonWorkdir : `${daemonWorkdir}${path.sep}`
+	return normalizedTarget === normalizedDaemon || normalizedTarget.startsWith(normalizedDaemon)
 }
 
-const pickByCwd = (entries: readonly RegistryEntry[]) => {
-	const cwd = process.cwd()
-	const withSep = cwd.endsWith(path.sep) ? cwd : `${cwd}${path.sep}`
+const pickByWorkdir = (entries: readonly RegistryEntry[], targetWorkdir: string) => {
+	const withSep = targetWorkdir.endsWith(path.sep) ? targetWorkdir : `${targetWorkdir}${path.sep}`
 	return entries
 		.filter((entry) => {
 			const workdir = entry.workdir.endsWith(path.sep) ? entry.workdir : `${entry.workdir}${path.sep}`
@@ -130,8 +133,6 @@ const pickByCwd = (entries: readonly RegistryEntry[]) => {
 		.sort((a, b) => b.workdir.length - a.workdir.length)[0] ?? null
 }
 
-const readRegistryEntry = () => pickByCwd(listAliveEntries())
-
 const expectedEnv = (config: DaemonConfig) => ({
 	MOTEL_OTEL_BASE_URL: config.baseUrl,
 	MOTEL_OTEL_QUERY_URL: config.baseUrl,
@@ -145,6 +146,7 @@ const expectedEnv = (config: DaemonConfig) => ({
 export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager => {
 	const config = resolveConfig(options)
 	const mapError = (error: unknown) => new DaemonError(error instanceof Error ? error.message : String(error))
+	const readRegistryEntry = () => pickByWorkdir(listAliveEntries(), config.workdir)
 
 	const fetchHealth = async (timeoutMs: number = HEALTH_FAST_TIMEOUT_MS): Promise<HealthShape | null> => {
 		try {
@@ -156,12 +158,39 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		}
 	}
 
+	const startupMarkers = [`Listening on ${config.baseUrl}`, `motel local telemetry server listening on ${config.baseUrl}`]
+
+	const readLogSince = async (offset: number) => {
+		try {
+			const raw = await fsp.readFile(config.logPath, "utf8")
+			return raw.slice(offset)
+		} catch {
+			return ""
+		}
+	}
+
+	const detectStartedFromLog = async (pid: number, offset: number): Promise<HealthShape | null> => {
+		if (!isAlive(pid)) return null
+		const tail = await readLogSince(offset)
+		if (!startupMarkers.some((marker) => tail.includes(marker))) return null
+		return {
+			ok: true,
+			service: MOTEL_SERVICE_ID,
+			databasePath: config.databasePath,
+			pid,
+			url: config.baseUrl,
+			workdir: config.workdir,
+			startedAt: new Date().toISOString(),
+			version: MOTEL_VERSION,
+		}
+	}
+
 	const describeManagedMismatch = (health: HealthShape) => {
 		if (health.service !== MOTEL_SERVICE_ID) {
 			return `Port ${config.port} is in use by ${health.service}, not ${MOTEL_SERVICE_ID}.`
 		}
-		if (!cwdMatches(health.workdir)) {
-			return `Port ${config.port} is serving motel for ${health.workdir}, not ${process.cwd()}.`
+		if (!workdirMatches(config.workdir, health.workdir)) {
+			return `Port ${config.port} is serving motel for ${health.workdir}, not ${config.workdir}.`
 		}
 		if (health.databasePath !== config.databasePath) {
 			return `Port ${config.port} is serving motel with ${health.databasePath}, expected ${config.databasePath}.`
@@ -181,8 +210,8 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 	 * 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 (!workdirMatches(config.workdir, entry.workdir)) {
+			return `Port ${config.port} is serving motel for ${entry.workdir}, not ${config.workdir}.`
 		}
 		if (entry.databasePath && entry.databasePath !== config.databasePath) {
 			return `Port ${config.port} is serving motel with ${entry.databasePath}, expected ${config.databasePath}.`
@@ -217,7 +246,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 			workdir: entry.workdir,
 			startedAt: entry.startedAt,
 			version: entry.version,
-			sameWorkdir: cwdMatches(entry.workdir),
+			sameWorkdir: workdirMatches(config.workdir, entry.workdir),
 			reason: mismatch,
 			logPath: config.logPath,
 			lockPath: config.lockPath,
@@ -276,7 +305,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		return fs.openSync(config.logPath, "a")
 	}
 
-	const waitForHealthy = async (pid: number) => {
+	const waitForHealthy = async (pid: number, logOffset: number) => {
 		const deadline = Date.now() + START_TIMEOUT_MS
 		while (Date.now() < deadline) {
 			const health = await fetchHealth()
@@ -285,6 +314,8 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				if (!mismatch) return health
 				throw new Error(mismatch)
 			}
+			const started = await detectStartedFromLog(pid, logOffset)
+			if (started) return started
 			if (!isAlive(pid)) {
 				// The spawned child is gone. Before declaring failure,
 				// do one patient probe: the child may have died from
@@ -299,7 +330,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				}
 				throw new Error(`Daemon process ${pid} exited before becoming healthy. See ${config.logPath}.`)
 			}
-			await sleep(POLL_INTERVAL_MS)
+			await sleep(START_POLL_INTERVAL_MS)
 		}
 		throw new Error(`Timed out waiting for daemon health at ${config.baseUrl}/api/health. See ${config.logPath}.`)
 	}
@@ -316,7 +347,9 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 		while (Date.now() < deadline) {
 			if (!isAlive(pid)) return
 			const health = await fetchHealth()
-			if (!health || health.pid !== pid) return
+			if (health && health.pid !== pid) return
+			const registry = readRegistryEntry()
+			if (!health && (!registry || registry.pid !== pid)) return
 			await sleep(POLL_INTERVAL_MS)
 		}
 
@@ -352,7 +385,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				workdir: registry?.workdir ?? null,
 				startedAt: registry?.startedAt ?? null,
 				version: registry?.version ?? null,
-				sameWorkdir: registry ? cwdMatches(registry.workdir) : false,
+				sameWorkdir: registry ? workdirMatches(config.workdir, registry.workdir) : false,
 				reason: registry ? "Registry entry exists but daemon is not healthy." : null,
 				logPath: config.logPath,
 				lockPath: config.lockPath,
@@ -371,7 +404,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 			workdir: health.workdir,
 			startedAt: health.startedAt,
 			version: health.version,
-			sameWorkdir: cwdMatches(health.workdir),
+			sameWorkdir: workdirMatches(config.workdir, health.workdir),
 			reason: mismatch,
 			logPath: config.logPath,
 			lockPath: config.lockPath,
@@ -404,10 +437,11 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 			}
 
 			const logFd = await openLogFile()
+			const logOffset = fs.fstatSync(logFd).size
 			try {
 				const proc = Bun.spawn({
-					cmd: [process.execPath, "run", "src/server.ts"],
-					cwd: config.repoRoot,
+					cmd: [process.execPath, "run", config.serverEntry],
+					cwd: config.workdir,
 					detached: true,
 					env: {
 						...process.env,
@@ -425,7 +459,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				throw new Error("Daemon failed to spawn.")
 			}
 
-			const health = await waitForHealthy(spawnedPid)
+			const health = await waitForHealthy(spawnedPid, logOffset)
 			return {
 				running: true,
 				managed: true,
@@ -436,7 +470,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 				workdir: health.workdir,
 				startedAt: health.startedAt,
 				version: health.version,
-				sameWorkdir: cwdMatches(health.workdir),
+				sameWorkdir: workdirMatches(config.workdir, health.workdir),
 				reason: null,
 				logPath: config.logPath,
 				lockPath: config.lockPath,
@@ -495,9 +529,7 @@ export const createDaemonManager = (options: DaemonOptions = {}): DaemonManager
 	}
 }
 
-const defaultManager = createDaemonManager()
-
-export const applyManagedDaemonEnv = defaultManager.applyEnv
-export const getManagedDaemonStatus = defaultManager.getStatus
-export const ensureManagedDaemon = defaultManager.ensure
-export const stopManagedDaemon = defaultManager.stop
+export const applyManagedDaemonEnv = Effect.suspend(() => createDaemonManager().applyEnv)
+export const getManagedDaemonStatus = Effect.suspend(() => createDaemonManager().getStatus)
+export const ensureManagedDaemon = Effect.suspend(() => createDaemonManager().ensure)
+export const stopManagedDaemon = Effect.suspend(() => createDaemonManager().stop)

package/src/index.tsx

@@ -1,7 +1,10 @@
 import { RegistryProvider } from "@effect/atom-react"
 import { createCliRenderer } from "@opentui/core"
 import { createRoot } from "@opentui/react"
-import { App } from "./App.js"
+import { startupBenchMark } from "./startupBench.js"
+import { StartupGate } from "./StartupGate.js"
+
+startupBenchMark("index_module_loaded")
 
 const renderer = await createCliRenderer({
 	exitOnCtrlC: false,
@@ -11,8 +14,12 @@ const renderer = await createCliRenderer({
 	},
 })
 
+startupBenchMark("renderer_ready")
+
 createRoot(renderer).render(
 	<RegistryProvider>
-		<App />
+		<StartupGate />
 	</RegistryProvider>,
 )
+
+startupBenchMark("root_render_called")

package/src/localServer.ts

@@ -9,10 +9,12 @@ 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 { attributeFiltersFromEntries, attributeContainsFiltersFromEntries } from "./queryFilters.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 { LogQueryService, LogQueryServiceLive } from "./services/LogQueryService.js"
+import { TelemetryStore, TelemetryStoreLive, TelemetryStoreReadonlyLive } from "./services/TelemetryStore.js"
+import { TraceQueryService, TraceQueryServiceLive } from "./services/TraceQueryService.js"
 import type { LogItem, TraceItem, TraceSummaryItem } from "./domain.js"
 import { lifecycleLabel } from "./ui/format.js"
 
@@ -39,6 +41,8 @@ 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 withTraceQuery = <A>(f: (query: TraceQueryService["Service"]) => Effect.Effect<A, Error>) => Effect.flatMap(TraceQueryService.asEffect(), f)
+const withLogQuery = <A>(f: (query: LogQueryService["Service"]) => Effect.Effect<A, Error>) => Effect.flatMap(LogQueryService.asEffect(), f)
 // 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.
@@ -72,14 +76,10 @@ const parseLookbackMinutes = (value: string | null, fallback: number) => {
 const parseBoundedLookbackMinutes = (value: string | null, fallback: number, max: number) => clamp(parseLookbackMinutes(value, fallback), 1, max)
 
 const attributeFiltersFromQuery = (url: URL) =>
-	attributeFiltersFromEntries(
-		[...url.searchParams.entries()].filter(([key]) => key.startsWith(ATTRIBUTE_FILTER_PREFIX) && !key.startsWith(ATTRIBUTE_CONTAINS_PREFIX)),
-	)
+	attributeFiltersFromEntries(url.searchParams.entries())
 
 const attributeContainsFiltersFromQuery = (url: URL) =>
-	attributeContainsFiltersFromEntries(
-		[...url.searchParams.entries()].filter(([key]) => key.startsWith(ATTRIBUTE_CONTAINS_PREFIX)),
-	)
+	attributeContainsFiltersFromEntries(url.searchParams.entries())
 
 type CursorShape =
 	| { readonly kind: "trace"; readonly startedAt: number; readonly id: string }
@@ -153,7 +153,7 @@ const loadLogsPage = (input: {
 	readonly lookbackMinutes: number
 	readonly cursor: CursorShape | null
 }) =>
-	Effect.flatMap(TelemetryStore.asEffect(), (store) =>
+	Effect.flatMap(LogQueryService.asEffect(), (store) =>
 		Effect.map(
 			store.searchLogs({
 				serviceName: input.serviceName,
@@ -316,7 +316,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					),
 				),
 			)
-			.handleRaw("services", () => respondJson(Effect.map(withStore((store) => store.listServices), (data) => ({ data }))))
+			.handleRaw("services", () => respondJson(Effect.map(withTraceQuery((store) => store.listServices), (data) => ({ data }))))
 			.handleRaw("traces", ({ request }) =>
 				respondRaw(Effect.gen(function*() {
 					const url = requestUrl(request)
@@ -324,7 +324,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					const limit = parseBoundedLimit(url.searchParams.get("limit"), TRACE_DEFAULT_LIMIT, TRACE_MAX_LIMIT)
 					const lookbackMinutes = parseBoundedLookbackMinutes(url.searchParams.get("lookback"), TRACE_DEFAULT_LOOKBACK, TRACE_MAX_LOOKBACK)
 					const cursor = decodeCursor(url.searchParams.get("cursor"))
-					const data = yield* withStore((store) => store.listTraceSummaries(service, {
+					const data = yield* withTraceQuery((store) => store.listTraceSummaries(service, {
 						limit: limit + 1,
 						lookbackMinutes,
 						cursorStartedAtMs: cursor?.kind === "trace" ? cursor.startedAt : undefined,
@@ -340,7 +340,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					const limit = parseBoundedLimit(url.searchParams.get("limit"), TRACE_DEFAULT_LIMIT, TRACE_MAX_LIMIT)
 					const lookbackMinutes = parseBoundedLookbackMinutes(url.searchParams.get("lookback"), TRACE_DEFAULT_LOOKBACK, TRACE_MAX_LOOKBACK)
 					const cursor = decodeCursor(url.searchParams.get("cursor"))
-					const data = yield* withStore((store) =>
+					const data = yield* withTraceQuery((store) =>
 						store.searchTraceSummaries({
 							serviceName: url.searchParams.get("service"),
 							operation: url.searchParams.get("operation"),
@@ -367,7 +367,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					if (!groupBy || (agg !== "count" && agg !== "avg_duration" && agg !== "p95_duration" && agg !== "error_rate")) {
 						return jsonResponse({ error: "Expected groupBy and agg=count|avg_duration|p95_duration|error_rate" }, 400)
 					}
-					const data = yield* withStore((store) =>
+					const data = yield* withTraceQuery((store) =>
 						store.traceStats({
 							groupBy,
 							agg,
@@ -390,7 +390,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					const attributeContainsFilters = attributeContainsFiltersFromQuery(url)
 					const limit = parseBoundedLimit(url.searchParams.get("limit"), SPAN_DEFAULT_LIMIT, SPAN_MAX_LIMIT)
 					const lookbackMinutes = parseBoundedLookbackMinutes(url.searchParams.get("lookback"), TRACE_DEFAULT_LOOKBACK, TRACE_MAX_LOOKBACK)
-					const data = yield* withStore((store) =>
+					const data = yield* withTraceQuery((store) =>
 						store.searchSpans({
 							serviceName: url.searchParams.get("service"),
 							traceId: url.searchParams.get("traceId"),
@@ -427,7 +427,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 				})),
 			)
 			.handleRaw("traceSpans", ({ params }) =>
-				respondJson(Effect.map(withStore((store) => store.listTraceSpans(params.traceId)), (data) => ({ data }))),
+				respondJson(Effect.map(withTraceQuery((store) => store.listTraceSpans(params.traceId)), (data) => ({ data }))),
 			)
 			.handleRaw("spanLogs", ({ params, request }) =>
 				respondRaw(Effect.gen(function*() {
@@ -440,14 +440,14 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 			)
 			.handleRaw("span", ({ params }) =>
 				respondRaw(
-					Effect.flatMap(withStore((store) => store.getSpan(params.spanId)), (data) =>
+					Effect.flatMap(withTraceQuery((store) => store.getSpan(params.spanId)), (data) =>
 						Effect.succeed(data ? jsonResponse({ data }) : notFoundResponse("Span not found")),
 					),
 				),
 			)
 			.handleRaw("trace", ({ params }) =>
 				respondRaw(
-					Effect.flatMap(withStore((store) => store.getTrace(params.traceId)), (data) =>
+					Effect.flatMap(withTraceQuery((store) => store.getTrace(params.traceId)), (data) =>
 						Effect.succeed(data ? jsonResponse({ data }) : notFoundResponse("Trace not found")),
 					),
 				),
@@ -464,7 +464,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					if (!groupBy || agg !== "count") {
 						return jsonResponse({ error: "Expected groupBy and agg=count" }, 400)
 					}
-					const data = yield* withStore((store) =>
+					const data = yield* withLogQuery((store) =>
 						store.logStats({
 							groupBy,
 							agg: "count",
@@ -512,7 +512,7 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 					if ((type !== "traces" && type !== "logs") || !field) {
 						return jsonResponse({ error: "Expected type=traces|logs and field=<name>" }, 400)
 					}
-					const data = yield* withStore((store) =>
+					const data = yield* withTraceQuery((store) =>
 						store.listFacets({
 							type,
 							field,
@@ -590,9 +590,9 @@ const TelemetryGroupLive = HttpApiBuilder.group(
 			)
 			.handleRaw("tracePage", ({ params }) =>
 				respondRaw(
-					Effect.flatMap(withStore((store) => store.getTrace(params.traceId)), (trace) =>
+					Effect.flatMap(withTraceQuery((store) => store.getTrace(params.traceId)), (trace) =>
 						trace
-							? Effect.map(withStore((store) => store.listTraceLogs(params.traceId)), (logs) => htmlResponse(renderTracePage(trace, logs)))
+							? Effect.map(withLogQuery((store) => store.listTraceLogs(params.traceId)), (logs) => htmlResponse(renderTracePage(trace, logs)))
 							: Effect.succeed(notFoundResponse("Trace not found")),
 					),
 				),
@@ -610,6 +610,10 @@ const ApiLayer = HttpApiBuilder.layer(MotelHttpApi, { openapiPath: "/openapi.jso
 	Layer.provide(HttpApiScalar.layer(MotelHttpApi, { scalar: { forceDarkModeState: "dark", showOperationId: true } })),
 )
 
+const QueryServicesLive = Layer.mergeAll(TraceQueryServiceLive, LogQueryServiceLive).pipe(
+	Layer.provideMerge(TelemetryStoreReadonlyLive),
+)
+
 // 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
@@ -679,9 +683,11 @@ export const ServerLive = HttpRouter.serve(
 	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.
+	// the writer TelemetryStore for ingest / maintenance. Query endpoints
+	// resolve through readonly TraceQueryService / LogQueryService so
+	// reads do not contend with the writer connection.
 	Layer.provideMerge(AsyncIngestLive),
+	Layer.provideMerge(QueryServicesLive),
 	Layer.provideMerge(TelemetryStoreLive),
 	Layer.provideMerge(BunHttpServer.layer({
 		port: config.otel.port,

package/src/motel.ts

@@ -12,7 +12,6 @@ case undefined:
 case "tui":
 case "ui": {
 	await run(applyManagedDaemonEnv)
-	await run(ensureManagedDaemon)
 	await import("./index.js")
 	break
 }
@@ -42,7 +41,6 @@ case "restart": {
 	// and want the TUI to reconnect to the new binary in one command.
 	await run(stopManagedDaemon)
 	await run(applyManagedDaemonEnv)
-	await run(ensureManagedDaemon)
 	await import("./index.js")
 	break
 }

package/src/services/AsyncIngest.ts

@@ -20,10 +20,11 @@
  */
 
 import * as BunWorker from "@effect/platform-bun/BunWorker"
-import { Context, Layer } from "effect"
+import { Context, Effect, Layer, Scope } from "effect"
 import * as RpcClient from "effect/unstable/rpc/RpcClient"
 import type { RpcClientError } from "effect/unstable/rpc/RpcClientError"
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import type { WorkerError } from "effect/unstable/workers/WorkerError"
 import { IngestRpcs } from "./ingestRpc.ts"
 
 // RpcClient.make always surfaces RpcClientError in addition to the
@@ -33,7 +34,7 @@ import { IngestRpcs } from "./ingestRpc.ts"
 // unrelated structural mismatches.
 export class AsyncIngest extends Context.Service<
 	AsyncIngest,
-	RpcClient.FromGroup<typeof IngestRpcs, RpcClientError>
+	RpcClient.FromGroup<typeof IngestRpcs, RpcClientError | WorkerError>
 >()("@motel/AsyncIngest") {}
 
 // Protocol: RpcClient.layerProtocolWorker manages a worker pool and
@@ -48,5 +49,22 @@ const WorkerProtocol = RpcClient.layerProtocolWorker({ size: 1 }).pipe(
 
 export const AsyncIngestLive = Layer.effect(
 	AsyncIngest,
-	RpcClient.make(IngestRpcs),
-).pipe(Layer.provide(WorkerProtocol))
+	Effect.gen(function*() {
+		const scope = yield* Scope.Scope
+		// Keep daemon startup cheap: creating the RPC client here would eagerly
+		// spawn the worker and make /api/health wait on the worker's SQLite
+		// bootstrap. Cache a lazy initializer instead so the worker only starts
+		// on the first ingest request, but is still shared thereafter.
+		const getClient = yield* Effect.gen(function*() {
+			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, scope)
+			return yield* RpcClient.make(IngestRpcs).pipe(
+				Effect.provide(protocolContext),
+				Effect.provideService(Scope.Scope, scope),
+			)
+		}).pipe(Effect.cached)
+		return {
+			ingestTraces: (input, options) => Effect.flatMap(getClient, (client) => client.ingestTraces(input, options)),
+			ingestLogs: (input, options) => Effect.flatMap(getClient, (client) => client.ingestLogs(input, options)),
+		}
+	}),
+)

package/src/services/LogQueryService.ts

@@ -7,8 +7,8 @@ export class LogQueryService extends Context.Service<
 	{
 		readonly listRecentLogs: (serviceName: string) => Effect.Effect<readonly LogItem[], Error>
 		readonly listTraceLogs: (traceId: string) => Effect.Effect<readonly LogItem[], Error>
-		readonly searchLogs: (input: { readonly serviceName?: string; readonly traceId?: string; readonly spanId?: string; readonly body?: string; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly LogItem[], Error>
-		readonly logStats: (input: { readonly groupBy: string; readonly agg: "count"; readonly serviceName?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly { readonly group: string; readonly value: number; readonly count: number }[], Error>
+		readonly searchLogs: (input: { readonly serviceName?: string | null; readonly severity?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly lookbackMinutes?: number; readonly limit?: number; readonly cursorTimestampMs?: number; readonly cursorId?: string; readonly attributeFilters?: Readonly<Record<string, string>>; readonly attributeContainsFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly LogItem[], Error>
+		readonly logStats: (input: { readonly groupBy: string; readonly agg: "count"; readonly serviceName?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly lookbackMinutes?: number; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>>; readonly attributeContainsFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly { readonly group: string; readonly value: number; readonly count: number }[], Error>
 		readonly listFacets: (input: { readonly type: "traces" | "logs"; readonly field: string; readonly serviceName?: string | null; readonly lookbackMinutes?: number; readonly limit?: number }) => Effect.Effect<readonly { readonly value: string; readonly count: number }[], Error>
 	}
 >()("motel/LogQueryService") {}