@kitlangton/motel 0.2.1 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitlangton/motel",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "A local OpenTelemetry ingest + TUI viewer for development, backed by SQLite.",
   "type": "module",
   "license": "MIT",
@@ -65,8 +65,8 @@
     "search-spans": "bun run src/cli.ts search-spans",
     "trace-stats": "bun run src/cli.ts trace-stats",
     "log-stats": "bun run src/cli.ts log-stats",
-    "web:dev": "cd web && npx vite",
-    "web:build": "cd web && npx vite build",
+    "web:dev": "bun run --cwd web dev",
+    "web:build": "bun run --cwd web build",
     "story:chat": "bun run src/storybook/aiChatStory.tsx",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "bun run web:build"

package/src/App.tsx

@@ -28,7 +28,7 @@ import { applyTheme, colors, SEPARATOR, themeLabel } from "./ui/theme.ts"
 import { useKeyboardNav } from "./ui/useKeyboardNav.ts"
 import { AttrFilterModal } from "./ui/AttrFilterModal.tsx"
 import { useAttrFilterPicker } from "./ui/useAttrFilterPicker.ts"
-import { getVisibleSpans } from "./ui/Waterfall.tsx"
+import { getVisibleSpans } from "./ui/waterfallModel.ts"
 
 const NOTICE_TIMEOUT_MS = 2500
 

package/src/daemon.test.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite"
 import { afterEach, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import * as fs from "node:fs"
@@ -30,6 +31,16 @@ const makeHarness = (): Harness => {
 	return { runtimeDir, port, databasePath, manager }
 }
 
+const withCwd = async <A>(cwd: string, f: () => Promise<A>): Promise<A> => {
+	const previous = process.cwd()
+	process.chdir(cwd)
+	try {
+		return await f()
+	} finally {
+		process.chdir(previous)
+	}
+}
+
 /**
  * Start a motel-shaped HTTP server on a test port that answers
  * /api/health with an arbitrary delay. Used to simulate a real daemon
@@ -193,4 +204,63 @@ describe("daemon manager", () => {
 		const finalStatus = await Effect.runPromise(harness.manager.getStatus)
 		expect(finalStatus.running).toBe(false)
 	})
+
+	test("becomes healthy even if trace summary rebuild hits a write lock", async () => {
+		const harness = makeHarness()
+		activeHarnesses.push(harness)
+
+		const firstStart = await Effect.runPromise(harness.manager.ensure)
+		expect(firstStart.running).toBe(true)
+		await Effect.runPromise(harness.manager.stop)
+
+		const locker = new Database(harness.databasePath)
+		locker.exec("BEGIN IMMEDIATE")
+		try {
+			const startedAt = performance.now()
+			const restarted = await Effect.runPromise(harness.manager.ensure)
+			const elapsed = performance.now() - startedAt
+			expect(restarted.running).toBe(true)
+			expect(restarted.managed).toBe(true)
+			expect(elapsed).toBeLessThan(10_000)
+		} finally {
+			locker.exec("ROLLBACK")
+			locker.close()
+		}
+	}, 20_000)
+
+	test("starts for the caller cwd even when motel is installed elsewhere", async () => {
+		const projectDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "motel-daemon-project-")))
+		const databasePath = path.join(projectDir, ".motel-data", "telemetry.sqlite")
+		let manager: ReturnType<typeof createDaemonManager> | null = null
+
+		try {
+			await withCwd(projectDir, async () => {
+				manager = createDaemonManager({
+					repoRoot,
+					port: randomPort(),
+				})
+
+				const started = await Effect.runPromise(manager.ensure)
+				expect(started.running).toBe(true)
+				expect(started.managed).toBe(true)
+				expect(started.workdir).toBe(projectDir)
+				expect(started.sameWorkdir).toBe(true)
+				expect(started.databasePath).toBe(databasePath)
+				expect(started.logPath).toBe(path.join(projectDir, ".motel-data", "daemon.log"))
+
+				const reused = await Effect.runPromise(manager.ensure)
+				expect(reused.pid).toBe(started.pid)
+
+				const stopped = await Effect.runPromise(manager.stop)
+				expect(stopped.running).toBe(false)
+			})
+		} finally {
+			await withCwd(projectDir, async () => {
+				if (manager) {
+					await Effect.runPromise(manager.stop).catch(() => undefined)
+				}
+			})
+			fs.rmSync(projectDir, { recursive: true, force: true })
+		}
+	})
 })

package/src/daemon.ts

@@ -2,14 +2,12 @@ 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 POLL_INTERVAL_MS = 150
@@ -44,6 +42,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 +79,7 @@ export type DaemonManager = {
 
 type DaemonOptions = {
 	readonly repoRoot?: string
+	readonly workdir?: string
 	readonly runtimeDir?: string
 	readonly databasePath?: string
 	readonly host?: string
@@ -96,12 +97,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 +116,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 +132,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 +145,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 +157,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 +209,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 +245,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 +304,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 +313,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
@@ -316,7 +346,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 +384,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 +403,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 +436,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 +458,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 +469,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 +528,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/localServer.ts

@@ -9,7 +9,7 @@ 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"
@@ -72,14 +72,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 }

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,20 @@ 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* RpcClient.make(IngestRpcs).pipe(
+			Effect.provide(WorkerProtocol),
+			Effect.cached,
+		)
+		const withScope = <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.provideService(effect, Scope.Scope, scope)
+		return {
+			ingestTraces: (input, options) => Effect.flatMap(withScope(getClient), (client) => client.ingestTraces(input, options)),
+			ingestLogs: (input, options) => Effect.flatMap(withScope(getClient), (client) => client.ingestLogs(input, options)),
+		}
+	}),
+)

package/src/services/TelemetryStore.ts

@@ -7,6 +7,9 @@ import type { AiCallDetail, AiCallSummary, FacetItem, LogItem, SpanItem, StatsIt
 import { AI_ATTR_MAP, AI_FTS_KEYS, AI_TEXT_SEARCH_KEYS, truncatePreview } from "../domain.js"
 import { attributeMap, nanosToMilliseconds, parseAnyValue, spanKindLabel, spanStatusLabel, stringifyValue, type OtlpLogExportRequest, type OtlpTraceExportRequest } from "../otlp.js"
 
+const isSqliteLockError = (error: unknown) =>
+	error instanceof Error && /(database is locked|database table is locked|SQLITE_BUSY)/i.test(error.message)
+
 interface SpanRow {
 	readonly trace_id: string
 	readonly span_id: string
@@ -502,108 +505,110 @@ export const makeTelemetryStoreLayer = (opts: TelemetryStoreOptions) => Layer.ef
 				PRAGMA mmap_size = 268435456;
 			`)
 		} else {
-		db.exec(`
-			PRAGMA journal_mode = WAL;
-			PRAGMA synchronous = NORMAL;
-			PRAGMA temp_store = MEMORY;
-			-- Longer busy timeout: the ingest worker holds the write lock
-			-- for up to a few seconds during big OTLP batches, and the main
-			-- daemon's retention passes can do the same. 15s gives either
-			-- side enough slack to serialise instead of erroring.
-			PRAGMA busy_timeout = 15000;
-			-- WAL checkpoint automatically when it grows past ~16MB. Without
-			-- this the WAL happily runs into the hundreds of MB and queries
-			-- start paying the cost of walking the WAL on every read.
-			PRAGMA wal_autocheckpoint = 4000;
-			-- Bump cache above the 2MB default. 64MB fits most hot index pages
-			-- (trace_summaries, spans, span_attributes indexes) in RAM even on
-			-- multi-GB databases, cutting cold-read latency meaningfully on
-			-- picker / search queries that sweep the index.
-			PRAGMA cache_size = -65536;
-			-- Let SQLite memory-map the first 256MB of the file. This is a
-			-- cheap way to avoid read() syscalls on hot pages and lets the OS
-			-- page cache serve index lookups directly. Safe on macOS and Linux;
-			-- SQLite silently caps at actual file size for smaller DBs.
-			PRAGMA mmap_size = 268435456;
-
-			CREATE TABLE IF NOT EXISTS spans (
-				trace_id TEXT NOT NULL,
-				span_id TEXT NOT NULL,
-				parent_span_id TEXT,
-				service_name TEXT NOT NULL,
-				scope_name TEXT,
-				operation_name TEXT NOT NULL,
-				kind TEXT,
-				start_time_ms INTEGER NOT NULL,
-				end_time_ms INTEGER NOT NULL,
-				duration_ms REAL NOT NULL,
-				status TEXT NOT NULL,
-				attributes_json TEXT NOT NULL,
-				resource_json TEXT NOT NULL,
-				events_json TEXT NOT NULL,
-				PRIMARY KEY (trace_id, span_id)
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_spans_service_time ON spans(service_name, start_time_ms DESC);
-			CREATE INDEX IF NOT EXISTS idx_spans_trace_time ON spans(trace_id, start_time_ms ASC);
-			CREATE INDEX IF NOT EXISTS idx_spans_span_id ON spans(span_id);
-			CREATE INDEX IF NOT EXISTS idx_spans_status_time ON spans(status, start_time_ms DESC);
-
-			CREATE TABLE IF NOT EXISTS logs (
-				id INTEGER PRIMARY KEY AUTOINCREMENT,
-				trace_id TEXT,
-				span_id TEXT,
-				service_name TEXT NOT NULL,
-				scope_name TEXT,
-				severity_text TEXT NOT NULL,
-				timestamp_ms INTEGER NOT NULL,
-				body TEXT NOT NULL,
-				attributes_json TEXT NOT NULL,
-				resource_json TEXT NOT NULL
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_logs_service_time ON logs(service_name, timestamp_ms DESC);
-			CREATE INDEX IF NOT EXISTS idx_logs_trace_time ON logs(trace_id, timestamp_ms DESC);
-			CREATE INDEX IF NOT EXISTS idx_logs_span_time ON logs(span_id, timestamp_ms DESC);
-			CREATE INDEX IF NOT EXISTS idx_logs_severity_time ON logs(severity_text, timestamp_ms DESC);
-
-			CREATE TABLE IF NOT EXISTS trace_summaries (
-				trace_id TEXT PRIMARY KEY,
-				service_name TEXT NOT NULL,
-				root_operation_name TEXT NOT NULL,
-				started_at_ms INTEGER NOT NULL,
-				ended_at_ms INTEGER NOT NULL,
-				active_span_count INTEGER NOT NULL DEFAULT 0,
-				duration_ms REAL NOT NULL,
-				span_count INTEGER NOT NULL,
-				error_count INTEGER NOT NULL
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_trace_summaries_started_at ON trace_summaries(started_at_ms DESC, trace_id DESC);
-			CREATE INDEX IF NOT EXISTS idx_trace_summaries_service_started_at ON trace_summaries(service_name, started_at_ms DESC, trace_id DESC);
-			CREATE INDEX IF NOT EXISTS idx_trace_summaries_duration ON trace_summaries(duration_ms DESC);
-
-			CREATE TABLE IF NOT EXISTS span_attributes (
-				trace_id TEXT NOT NULL,
-				span_id TEXT NOT NULL,
-				key TEXT NOT NULL,
-				value TEXT NOT NULL,
-				PRIMARY KEY (trace_id, span_id, key)
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_span_attributes_key_value ON span_attributes(key, value, trace_id, span_id);
-			CREATE INDEX IF NOT EXISTS idx_span_attributes_trace_span ON span_attributes(trace_id, span_id);
-
-			CREATE TABLE IF NOT EXISTS log_attributes (
-				log_id INTEGER NOT NULL,
-				key TEXT NOT NULL,
-				value TEXT NOT NULL,
-				PRIMARY KEY (log_id, key)
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_log_attributes_key_value ON log_attributes(key, value, log_id);
-			CREATE INDEX IF NOT EXISTS idx_log_attributes_log_id ON log_attributes(log_id);
-		`)
+			db.exec(`
+				-- Bump cache above the 2MB default. 64MB fits most hot index pages
+				-- (trace_summaries, spans, span_attributes indexes) in RAM even on
+				-- multi-GB databases, cutting cold-read latency meaningfully on
+				-- picker / search queries that sweep the index.
+				PRAGMA cache_size = -65536;
+				-- Let SQLite memory-map the first 256MB of the file. This is a
+				-- cheap way to avoid read() syscalls on hot pages and lets the OS
+				-- page cache serve index lookups directly. Safe on macOS and Linux;
+				-- SQLite silently caps at actual file size for smaller DBs.
+				PRAGMA mmap_size = 268435456;
+			`)
+			try {
+				db.exec(`
+					PRAGMA journal_mode = WAL;
+					PRAGMA synchronous = NORMAL;
+					PRAGMA temp_store = MEMORY;
+					-- WAL checkpoint automatically when it grows past ~16MB. Without
+					-- this the WAL happily runs into the hundreds of MB and queries
+					-- start paying the cost of walking the WAL on every read.
+					PRAGMA wal_autocheckpoint = 4000;
+
+					CREATE TABLE IF NOT EXISTS spans (
+						trace_id TEXT NOT NULL,
+						span_id TEXT NOT NULL,
+						parent_span_id TEXT,
+						service_name TEXT NOT NULL,
+						scope_name TEXT,
+						operation_name TEXT NOT NULL,
+						kind TEXT,
+						start_time_ms INTEGER NOT NULL,
+						end_time_ms INTEGER NOT NULL,
+						duration_ms REAL NOT NULL,
+						status TEXT NOT NULL,
+						attributes_json TEXT NOT NULL,
+						resource_json TEXT NOT NULL,
+						events_json TEXT NOT NULL,
+						PRIMARY KEY (trace_id, span_id)
+					);
+
+					CREATE INDEX IF NOT EXISTS idx_spans_service_time ON spans(service_name, start_time_ms DESC);
+					CREATE INDEX IF NOT EXISTS idx_spans_trace_time ON spans(trace_id, start_time_ms ASC);
+					CREATE INDEX IF NOT EXISTS idx_spans_span_id ON spans(span_id);
+					CREATE INDEX IF NOT EXISTS idx_spans_status_time ON spans(status, start_time_ms DESC);
+
+					CREATE TABLE IF NOT EXISTS logs (
+						id INTEGER PRIMARY KEY AUTOINCREMENT,
+						trace_id TEXT,
+						span_id TEXT,
+						service_name TEXT NOT NULL,
+						scope_name TEXT,
+						severity_text TEXT NOT NULL,
+						timestamp_ms INTEGER NOT NULL,
+						body TEXT NOT NULL,
+						attributes_json TEXT NOT NULL,
+						resource_json TEXT NOT NULL
+					);
+
+					CREATE INDEX IF NOT EXISTS idx_logs_service_time ON logs(service_name, timestamp_ms DESC);
+					CREATE INDEX IF NOT EXISTS idx_logs_trace_time ON logs(trace_id, timestamp_ms DESC);
+					CREATE INDEX IF NOT EXISTS idx_logs_span_time ON logs(span_id, timestamp_ms DESC);
+					CREATE INDEX IF NOT EXISTS idx_logs_severity_time ON logs(severity_text, timestamp_ms DESC);
+
+					CREATE TABLE IF NOT EXISTS trace_summaries (
+						trace_id TEXT PRIMARY KEY,
+						service_name TEXT NOT NULL,
+						root_operation_name TEXT NOT NULL,
+						started_at_ms INTEGER NOT NULL,
+						ended_at_ms INTEGER NOT NULL,
+						active_span_count INTEGER NOT NULL DEFAULT 0,
+						duration_ms REAL NOT NULL,
+						span_count INTEGER NOT NULL,
+						error_count INTEGER NOT NULL
+					);
+
+					CREATE INDEX IF NOT EXISTS idx_trace_summaries_started_at ON trace_summaries(started_at_ms DESC, trace_id DESC);
+					CREATE INDEX IF NOT EXISTS idx_trace_summaries_service_started_at ON trace_summaries(service_name, started_at_ms DESC, trace_id DESC);
+					CREATE INDEX IF NOT EXISTS idx_trace_summaries_duration ON trace_summaries(duration_ms DESC);
+
+					CREATE TABLE IF NOT EXISTS span_attributes (
+						trace_id TEXT NOT NULL,
+						span_id TEXT NOT NULL,
+						key TEXT NOT NULL,
+						value TEXT NOT NULL,
+						PRIMARY KEY (trace_id, span_id, key)
+					);
+
+					CREATE INDEX IF NOT EXISTS idx_span_attributes_key_value ON span_attributes(key, value, trace_id, span_id);
+					CREATE INDEX IF NOT EXISTS idx_span_attributes_trace_span ON span_attributes(trace_id, span_id);
+
+					CREATE TABLE IF NOT EXISTS log_attributes (
+						log_id INTEGER NOT NULL,
+						key TEXT NOT NULL,
+						value TEXT NOT NULL,
+						PRIMARY KEY (log_id, key)
+					);
+
+					CREATE INDEX IF NOT EXISTS idx_log_attributes_key_value ON log_attributes(key, value, log_id);
+					CREATE INDEX IF NOT EXISTS idx_log_attributes_log_id ON log_attributes(log_id);
+				`)
+			} catch (err) {
+				if (!isSqliteLockError(err)) throw err
+				console.warn(`motel: writer bootstrap skipped during startup: ${(err as Error).message}`)
+			}
 		}
 
 		// Tables detected at runtime. For writer connections these flags are
@@ -726,6 +731,12 @@ export const makeTelemetryStoreLayer = (opts: TelemetryStoreOptions) => Layer.ef
 			// ANALYZE / optimize failures are never fatal — queries still work,
 			// they just run with default row estimates.
 		}
+			// Longer busy timeout: the ingest worker holds the write lock for up
+			// to a few seconds during big OTLP batches, and the daemon's retention
+			// passes can do the same. Apply this AFTER startup maintenance so
+			// lock-conflicted bootstrap steps fail fast instead of stalling health
+			// for the full 15s timeout.
+			try { db.exec(`PRAGMA busy_timeout = 15000;`) } catch { /* ignore */ }
 		} // end: if (!opts.readonly) writer init
 
 		const insertSpan = db.query(`
@@ -774,14 +785,15 @@ export const makeTelemetryStoreLayer = (opts: TelemetryStoreOptions) => Layer.ef
 			GROUP BY trace_id
 		`)
 
-		// One-time full rebuild of the trace_summaries table at open so
-		// any drift from interrupted ingests gets reconciled. Writer-only
-		// because the DELETE + INSERT would fail on a readonly connection
-		// (and would fight the daemon's writer for the lock anyway).
-		if (!opts.readonly) {
-			db.query(`DELETE FROM trace_summaries`).run()
-			rebuildTraceSummaries.run()
-		}
+		const reconcileTraceSummaries = Effect.sync(() => {
+			try {
+				db.query(`DELETE FROM trace_summaries`).run()
+				rebuildTraceSummaries.run()
+			} catch (err) {
+				if (!isSqliteLockError(err)) throw err
+				console.warn(`motel: trace summary rebuild skipped during startup: ${(err as Error).message}`)
+			}
+		})
 
 		const deleteSpanAttributes = db.query(`DELETE FROM span_attributes WHERE trace_id = ? AND span_id = ?`)
 		const insertSpanAttribute = db.query(`INSERT INTO span_attributes (trace_id, span_id, key, value) VALUES (?, ?, ?, ?)`)
@@ -887,6 +899,12 @@ export const makeTelemetryStoreLayer = (opts: TelemetryStoreOptions) => Layer.ef
 		// daemon). The ingest worker and TUI skip it to avoid two writers
 		// competing for the write lock with overlapping DELETE passes.
 		if (opts.runRetention) {
+			// Reconcile any summary drift from interrupted ingests, but do it
+			// after the server becomes healthy. Running this synchronously at
+			// open can sit behind another writer's lock for ~15s and make the
+			// daemon look hung even though the port is already bound.
+			yield* Effect.forkScoped(reconcileTraceSummaries)
+
 			// Enable incremental vacuum so retention can reclaim freed
 			// pages over time instead of needing a stop-the-world VACUUM.
 			// Idempotent: repeat calls after the first are no-ops.

package/src/storybook/aiChatStory.tsx

@@ -212,6 +212,7 @@ const StoryApp = () => {
 				bodyLines={bodyLines}
 				paneWidth={w}
 			/>
+			<Divider width={contentWidth} />
 			<box paddingLeft={1} paddingRight={1} height={FOOTER_ROWS}>
 				<TextLine>
 					<span fg={colors.count} attributes={TextAttributes.BOLD}>1-9</span>

package/src/ui/AiChatView.tsx

@@ -48,6 +48,16 @@ const rowTextColor = (chunk: Chunk | null, role: Role, selected: boolean): strin
 	return colors.text
 }
 
+const splitToolRowText = (text: string): { readonly head: string; readonly tail: string | null } => {
+	const match = text.match(/\s{2,}/)
+	const sep = match?.index ?? -1
+	if (sep < 0) return { head: text, tail: null }
+	return {
+		head: text.slice(0, sep),
+		tail: text.slice(sep + match![0].length),
+	}
+}
+
 const clamp = (n: number, min: number, max: number) => Math.max(min, Math.min(max, n))
 
 const chunkRows = (rows: readonly ChatListRow[]) => rows.filter((row) => row.kind === "chunk")
@@ -151,15 +161,16 @@ export const AiChatView = ({
 }) => {
 	const rows = useMemo(() => buildChatListRows(chunks), [chunks])
 	const selectable = useMemo(() => chunkRows(rows), [rows])
+	const chunkById = useMemo(() => new Map(chunks.map((chunk) => [chunk.id, chunk] as const)), [chunks])
+	const selectedOrdinal = useMemo(
+		() => selectedChunkId ? selectable.findIndex((row) => row.chunkId === selectedChunkId) : -1,
+		[selectable, selectedChunkId],
+	)
 	const [scrollOffset, setScrollOffset] = useState(0)
 
-	const selectedChunk = useMemo(
-		() => selectedChunkId ? chunks.find((chunk) => chunk.id === selectedChunkId) ?? null : null,
-		[chunks, selectedChunkId],
-	)
 	const detailChunk = useMemo(
-		() => detailChunkId ? chunks.find((chunk) => chunk.id === detailChunkId) ?? null : null,
-		[chunks, detailChunkId],
+		() => detailChunkId ? chunkById.get(detailChunkId) ?? null : null,
+		[chunkById, detailChunkId],
 	)
 
 	const selectedRowIndex = useMemo(
@@ -201,7 +212,7 @@ export const AiChatView = ({
 	const maxOffset = Math.max(0, rows.length - bodyLines)
 	const offset = clamp(scrollOffset, 0, maxOffset)
 	const visible = rows.slice(offset, offset + bodyLines)
-	const headerRight = `${operation} ${SEPARATOR} ${durationLabel} ${SEPARATOR} ${selectable.length > 0 ? `${Math.max(1, selectable.findIndex((row) => row.chunkId === selectedChunkId) + 1)}/${selectable.length}` : "0/0"}`
+	const headerRight = `${operation} ${SEPARATOR} ${durationLabel} ${SEPARATOR} ${selectable.length > 0 ? `${Math.max(1, selectedOrdinal + 1)}/${selectable.length}` : "0/0"}`
 	const handleListWheel = (event: MouseScrollEvent) => {
 		if (detailChunk) return
 		const delta = scrollDelta(event)
@@ -257,18 +268,23 @@ export const AiChatView = ({
 								</TextLine>
 							)
 						}
-						const chunk = chunks.find((candidate) => candidate.id === row.chunkId) ?? null
+						const chunk = row.chunkId ? chunkById.get(row.chunkId) ?? null : null
 						const isSelected = row.chunkId === selectedChunkId
 						const prefix = rowPrefix(chunk)
 						const meta = row.meta ?? ""
 						const textWidth = Math.max(8, contentWidth - prefix.length - meta.length - 4)
 						const display = truncateText(row.text, textWidth)
 						const gap = Math.max(1, contentWidth - prefix.length - display.length - meta.length - 1)
+						const toolLike = chunk?.kind === "tool-call" || chunk?.kind === "tool-result"
+						const { head, tail } = toolLike ? splitToolRowText(display) : { head: display, tail: null }
+						const headColor = rowTextColor(chunk, row.role, isSelected)
+						const tailColor = isSelected ? colors.muted : colors.separator
 						return (
 							<box key={`row-${offset + i}`} height={1} onMouseDown={() => { if (row.chunkId) onSelectChunk(row.chunkId) }}>
 								<TextLine bg={isSelected ? colors.selectedBg : undefined}>
 									<span fg={isSelected ? roleColor(row.role) : colors.separator}>{isSelected ? "▎" : " "}</span>
-									<span fg={rowTextColor(chunk, row.role, isSelected)} attributes={isSelected ? TextAttributes.BOLD : undefined}>{prefix}{display}</span>
+									<span fg={headColor} attributes={isSelected ? TextAttributes.BOLD : undefined}>{`${prefix}${head}`}</span>
+									{tail ? <span fg={tailColor}>{` ${tail}`}</span> : null}
 									{meta ? <><span fg={colors.muted}>{" ".repeat(gap)}</span><span fg={colors.muted}>{meta}</span></> : null}
 								</TextLine>
 							</box>

package/src/ui/TraceDetailsPane.tsx

@@ -5,7 +5,7 @@ import { AlignedHeaderLine, Divider, FilterBar, PlainLine, TextLine } from "./pr
 import { WaterfallTimeline } from "./Waterfall.tsx"
 import { computeMatchingSpanIds } from "./waterfallFilter.ts"
 import { getVisibleSpans } from "./waterfallModel.ts"
-import type { LoadStatus, LogState } from "./state.ts"
+import type { LoadStatus } from "./state.ts"
 import { colors, SEPARATOR } from "./theme.ts"
 
 /**
@@ -24,13 +24,12 @@ export const TraceDetailsPane = ({
 	traceSummary,
 	traceStatus,
 	traceError,
-	traceLogsState,
+	traceLogCount,
 	contentWidth,
 	bodyLines,
 	paneWidth,
 	selectedSpanIndex,
 	collapsedSpanIds,
-	focused = false,
 	onSelectSpan,
 	waterfallFilterMode,
 	waterfallFilterText,
@@ -39,13 +38,12 @@ export const TraceDetailsPane = ({
 	traceSummary: TraceSummaryItem | null
 	traceStatus: LoadStatus
 	traceError: string | null
-	traceLogsState: LogState
+	traceLogCount: number
 	contentWidth: number
 	bodyLines: number
 	paneWidth: number
 	selectedSpanIndex: number | null
 	collapsedSpanIds: ReadonlySet<string>
-	focused?: boolean
 	onSelectSpan: (index: number) => void
 	waterfallFilterMode: boolean
 	waterfallFilterText: string
@@ -54,20 +52,6 @@ export const TraceDetailsPane = ({
 		() => trace ? getVisibleSpans(trace.spans, collapsedSpanIds) : [],
 		[trace, collapsedSpanIds],
 	)
-	const selectedSpan = selectedSpanIndex !== null ? filteredSpans[selectedSpanIndex] ?? null : null
-	const traceLogCount = traceLogsState.data.length
-	const spanLogCounts = useMemo(() => {
-		const counts = new Map<string, number>()
-		for (const log of traceLogsState.data) {
-			if (!log.spanId) continue
-			counts.set(log.spanId, (counts.get(log.spanId) ?? 0) + 1)
-		}
-		return counts
-	}, [traceLogsState.data])
-	const selectedSpanLogs = useMemo(
-		() => selectedSpan ? traceLogsState.data.filter((log) => log.spanId === selectedSpan.spanId) : [],
-		[selectedSpan, traceLogsState.data],
-	)
 	const matchingSpanIds = useMemo(
 		() => trace ? computeMatchingSpanIds(trace.spans, waterfallFilterText) : null,
 		[trace, waterfallFilterText],
@@ -144,14 +128,12 @@ export const TraceDetailsPane = ({
 						</box>
 					) : null}
 					<box flexDirection="column" paddingLeft={1} paddingRight={1}>
-						<WaterfallTimeline
-							trace={trace}
-							filteredSpans={filteredSpans}
-							spanLogCounts={spanLogCounts}
-							selectedSpanLogs={selectedSpanLogs}
-							contentWidth={contentWidth}
-							bodyLines={waterfallBodyLines}
-							selectedSpanIndex={selectedSpanIndex}
+					<WaterfallTimeline
+						trace={trace}
+						filteredSpans={filteredSpans}
+						contentWidth={contentWidth}
+						bodyLines={waterfallBodyLines}
+						selectedSpanIndex={selectedSpanIndex}
 							collapsedSpanIds={collapsedSpanIds}
 							matchingSpanIds={matchingSpanIds}
 							onSelectSpan={onSelectSpan}

package/src/ui/Waterfall.tsx

@@ -1,4 +1,4 @@
-import { memo, useLayoutEffect, useRef, useState } from "react"
+import { memo, useLayoutEffect, useState } from "react"
 import { isAiSpan, type LogItem, type TraceItem, type TraceSpanItem } from "../domain.ts"
 import { formatDuration, lifecycleLabel, splitDuration, truncateText } from "./format.ts"
 import { BlankRow, TextLine } from "./primitives.tsx"
@@ -280,8 +280,6 @@ export const SpanPreview = ({
 export const WaterfallTimeline = ({
 	trace,
 	filteredSpans,
-	spanLogCounts,
-	selectedSpanLogs,
 	contentWidth,
 	bodyLines,
 	selectedSpanIndex,
@@ -291,8 +289,6 @@ export const WaterfallTimeline = ({
 }: {
 	trace: TraceItem
 	filteredSpans: readonly TraceSpanItem[]
-	spanLogCounts: ReadonlyMap<string, number>
-	selectedSpanLogs: readonly LogItem[]
 	contentWidth: number
 	bodyLines: number
 	selectedSpanIndex: number | null
@@ -320,13 +316,12 @@ export const WaterfallTimeline = ({
 	const viewportSize = Math.max(1, bodyLines)
 	const maxOffset = Math.max(0, filteredSpans.length - viewportSize)
 	const [scrollOffset, setScrollOffset] = useState(0)
-	const lastTraceIdRef = useRef<string | null>(null)
 
-	// Reset scroll offset when the trace changes.
-	if (trace.traceId !== lastTraceIdRef.current) {
+	// Reset scroll offset when the trace changes. Keep this out of render so
+	// a trace switch doesn't force a render-phase state update on hot paths.
+	useLayoutEffect(() => {
 		setScrollOffset(0)
-		lastTraceIdRef.current = trace.traceId
-	}
+	}, [trace.traceId])
 
 	// Auto-follow selection: only if the selected span would be hidden
 	// by the current window, shift just enough to bring it back. Runs in

package/src/ui/aiChatModel.test.ts

@@ -328,6 +328,50 @@ describe("buildChatListRows", () => {
 		expect(rows[0]!.text).toBe("hello there")
 		expect(rows[1]!.text).toContain("bash")
 	})
+
+	it("uses matching tool-call context for tool-result rows", () => {
+		const chunks = buildChunks(
+			makeDetail([
+				{
+					role: "assistant",
+					content: [
+						{ type: "tool-call", toolCallId: "tc-1", toolName: "bash", input: { command: "git status --short --branch" } },
+					],
+				},
+				{
+					role: "tool",
+					content: [
+						{ type: "tool-result", toolCallId: "tc-1", toolName: "bash", output: { type: "text", value: "## dev...origin/dev [ahead 8, behind 11]\n M src/file.ts" } },
+					],
+				},
+			]),
+		)
+		const rows = buildChatListRows(chunks).filter((r) => r.kind === "chunk")
+		expect(rows[1]!.text).toContain("bash  git status --short --branch")
+		expect(rows[1]!.meta).toContain("## dev...origin/dev")
+	})
+
+	it("shows read result rows with the originating file path inline", () => {
+		const chunks = buildChunks(
+			makeDetail([
+				{
+					role: "assistant",
+					content: [
+						{ type: "tool-call", toolCallId: "tc-2", toolName: "read", input: { filePath: "/src/formatter.ts", offset: 40, limit: 80 } },
+					],
+				},
+				{
+					role: "tool",
+					content: [
+						{ type: "tool-result", toolCallId: "tc-2", toolName: "read", output: { type: "text", value: "1: export const x = 1" } },
+					],
+				},
+			]),
+		)
+		const rows = buildChatListRows(chunks).filter((r) => r.kind === "chunk")
+		expect(rows[1]!.text).toContain("read  /src/formatter.ts @40 +80")
+		expect(rows[1]!.meta).toContain("1: export const x = 1")
+	})
 })
 
 describe("chunkDetailTitle + renderChunkDetailLines", () => {

package/src/ui/aiChatModel.ts

@@ -479,6 +479,13 @@ const firstBodyLine = (body: string) => {
 	return line.replace(/\s+/g, " ").trim()
 }
 
+const stripTransportGlyph = (text: string) => text.replace(/^[→←]\s+/, "")
+
+const toolRowPreview = (text: string, width = 40) => {
+	const compact = firstBodyLine(text)
+	return compact.length > 0 ? shorten(compact, width) : null
+}
+
 /**
  * Stable list rows for the main chat pane. One role divider per turn,
  * one selectable row per chunk. Plain text chunks use their first body
@@ -487,6 +494,10 @@ const firstBodyLine = (body: string) => {
  */
 export const buildChatListRows = (chunks: readonly Chunk[]): readonly ChatListRow[] => {
 	const rows: ChatListRow[] = []
+	const toolCallById = new Map<string, Chunk>()
+	for (const chunk of chunks) {
+		if (chunk.kind === "tool-call" && chunk.toolCallId) toolCallById.set(chunk.toolCallId, chunk)
+	}
 	let prevRole: Role | null = null
 	let prevMessageIndex = -1
 
@@ -522,7 +533,33 @@ export const buildChatListRows = (chunks: readonly Chunk[]): readonly ChatListRo
 		// structured chunk headers here. Otherwise tool rows render as
 		// `→ → bash ...` and results as `← ← read ...`.
 		if (chunk.kind === "tool-call" || chunk.kind === "tool-result") {
-			text = text.replace(/^[→←]\s+/, "")
+			text = stripTransportGlyph(text)
+		}
+
+		if (chunk.kind === "tool-call") {
+			const preview = toolRowPreview(chunk.body)
+			// Keep row text focused on the primary action (already encoded in
+			// `header`) and use the dim right column for "there is more here"
+			// metadata only when it adds signal. For JSON-heavy tool args this
+			// is usually just noise, so we currently leave meta alone.
+			if (preview && preview !== text) {
+				meta = meta ?? null
+			}
+		}
+
+		if (chunk.kind === "tool-result") {
+			const matchingCall = chunk.toolCallId ? toolCallById.get(chunk.toolCallId) ?? null : null
+			if (matchingCall) {
+				// Carry the originating call summary into the result row so the
+				// list can answer "result of what?" without opening the modal.
+				// Example: `← bash  git status --short --branch`,
+				// `← read  /src/formatter.ts @40 +80`.
+				text = stripTransportGlyph(matchingCall.header)
+			}
+			const preview = toolRowPreview(chunk.body)
+			if (preview) {
+				meta = chunk.headerMeta ? `${chunk.headerMeta} · ${preview}` : preview
+			}
 		}
 		if (chunk.kind === "system") {
 			text = "prompt"

package/src/ui/app/TraceWorkspace.tsx

@@ -21,7 +21,7 @@ interface SharedTraceDetailsProps {
 	readonly traceSummary: TraceSummaryItem | null
 	readonly traceStatus: TraceDetailState["status"]
 	readonly traceError: string | null
-	readonly traceLogsState: LogState
+	readonly traceLogCount: number
 	readonly selectedSpanIndex: number | null
 	readonly collapsedSpanIds: ReadonlySet<string>
 	readonly waterfallFilterMode: boolean
@@ -33,7 +33,6 @@ interface TraceDetailsSceneProps extends SharedTraceDetailsProps {
 	readonly contentWidth: number
 	readonly bodyLines: number
 	readonly paneWidth: number
-	readonly focused: boolean
 }
 
 const TraceDetailsScene = ({
@@ -41,13 +40,12 @@ const TraceDetailsScene = ({
 	traceSummary,
 	traceStatus,
 	traceError,
-	traceLogsState,
+	traceLogCount,
 	contentWidth,
 	bodyLines,
 	paneWidth,
 	selectedSpanIndex,
 	collapsedSpanIds,
-	focused,
 	waterfallFilterMode,
 	waterfallFilterText,
 	onSelectSpan,
@@ -57,13 +55,12 @@ const TraceDetailsScene = ({
 		traceSummary={traceSummary}
 		traceStatus={traceStatus}
 		traceError={traceError}
-		traceLogsState={traceLogsState}
+		traceLogCount={traceLogCount}
 		contentWidth={contentWidth}
 		bodyLines={bodyLines}
 		paneWidth={paneWidth}
 		selectedSpanIndex={selectedSpanIndex}
 		collapsedSpanIds={collapsedSpanIds}
-		focused={focused}
 		waterfallFilterMode={waterfallFilterMode}
 		waterfallFilterText={waterfallFilterText}
 		onSelectSpan={onSelectSpan}
@@ -292,7 +289,7 @@ export const TraceWorkspace = ({
 		traceSummary: selectedTraceSummary,
 		traceStatus: traceDetailState.status,
 		traceError: traceDetailState.error,
-		traceLogsState: logState,
+		traceLogCount: logState.data.length,
 		selectedSpanIndex,
 		collapsedSpanIds,
 		waterfallFilterMode,
@@ -336,7 +333,6 @@ export const TraceWorkspace = ({
 							contentWidth={rightContentWidth}
 							bodyLines={wideBodyLines}
 							paneWidth={rightPaneWidth}
-							focused={false}
 						/>
 					</box>
 				</box>
@@ -352,7 +348,6 @@ export const TraceWorkspace = ({
 							contentWidth={leftContentWidth}
 							bodyLines={wideBodyLines}
 							paneWidth={leftPaneWidth}
-							focused={true}
 						/>
 					</box>
 					<SeparatorColumn height={wideBodyHeight} junctionChars={separatorCrossChars} />
@@ -412,7 +407,6 @@ export const TraceWorkspace = ({
 					contentWidth={rightContentWidth}
 					bodyLines={narrowBodyLines}
 					paneWidth={contentWidth}
-					focused={false}
 				/>
 			</>
 		)
@@ -432,7 +426,6 @@ export const TraceWorkspace = ({
 					contentWidth={rightContentWidth}
 					bodyLines={narrowFullBodyLines}
 					paneWidth={contentWidth}
-					focused={true}
 				/>
 			) : (
 				<SpanDrillInScene

package/src/ui/app/useTraceScreenData.ts

@@ -47,7 +47,7 @@ import {
 import { isAiSpan } from "../../domain.ts"
 import { buildChunks, type Chunk } from "../aiChatModel.ts"
 import { parseFilterText } from "../filterParser.ts"
-import { getVisibleSpans } from "../Waterfall.tsx"
+import { getVisibleSpans } from "../waterfallModel.ts"
 
 const clampSelectionIndex = (index: number, length: number) => {
 	if (length === 0) return 0

package/src/ui/useKeyboardNav.ts

@@ -39,7 +39,7 @@ import { filterFacets } from "./AttrFilterModal.tsx"
 import { G_PREFIX_TIMEOUT_MS } from "./theme.ts"
 import { cycleThemeName, themeLabel } from "./theme.ts"
 import { computeMatchingSpanIds, findAdjacentMatch } from "./waterfallFilter.ts"
-import { getVisibleSpans } from "./Waterfall.tsx"
+import { getVisibleSpans } from "./waterfallModel.ts"
 import { resolveCollapseStep } from "./waterfallNav.ts"
 
 /**