@cuongtran001/kanna 0.39.2

package/src/server/event-store.ts

@@ -0,0 +1,1421 @@
+import { appendFile, mkdir, rename, rm, writeFile } from "node:fs/promises"
+import { existsSync, readFileSync as readFileSyncImmediate } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import { getDataDir, LOG_PREFIX } from "../shared/branding"
+import type { AgentProvider, ChatHistoryPage, ChatHistorySnapshot, QueuedChatMessage, SlashCommand, TranscriptEntry } from "../shared/types"
+import { STORE_VERSION } from "../shared/types"
+import type { AutoContinueEvent } from "./auto-continue/events"
+import {
+  type ChatEvent,
+  type ProjectEvent,
+  type QueuedMessageEvent,
+  type SnapshotFile,
+  type StoreEvent,
+  type StoreState,
+  type TurnEvent,
+  cloneTranscriptEntries,
+  createEmptyState,
+} from "./events"
+import { resolveLocalPath } from "./paths"
+import type { CloudflareTunnelEvent } from "./cloudflare-tunnel/events"
+
+const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
+const STALE_EMPTY_CHAT_MAX_AGE_MS = 30 * 60 * 1000
+const SIDEBAR_PROJECT_ORDER_FILE = "sidebar-order.json"
+
+function normalizeSidebarProjectOrder(value: unknown) {
+  if (!Array.isArray(value)) {
+    return []
+  }
+
+  const seen = new Set<string>()
+  const projectIds: string[] = []
+  for (const entry of value) {
+    if (typeof entry !== "string") continue
+    const projectId = entry.trim()
+    if (!projectId || seen.has(projectId)) continue
+    seen.add(projectId)
+    projectIds.push(projectId)
+  }
+
+  return projectIds
+}
+
+function isSendToStartingProfilingEnabled() {
+  return process.env.KANNA_PROFILE_SEND_TO_STARTING === "1"
+}
+
+function logSendToStartingProfile(stage: string, details?: Record<string, unknown>) {
+  if (!isSendToStartingProfilingEnabled()) {
+    return
+  }
+
+  console.log("[kanna/send->starting][server]", JSON.stringify({
+    stage,
+    ...details,
+  }))
+}
+
+interface LegacyTranscriptStats {
+  hasLegacyData: boolean
+  sources: Array<"snapshot" | "messages_log">
+  chatCount: number
+  entryCount: number
+}
+
+interface TranscriptPageResult {
+  entries: TranscriptEntry[]
+  hasOlder: boolean
+  olderCursor: string | null
+}
+
+interface ParsedReplayEvent {
+  event: StoreEvent
+  sourceIndex: number
+  lineIndex: number
+}
+
+function getReplayEventPriority(event: StoreEvent) {
+  const discriminator = "type" in event ? event.type : event.kind
+  switch (discriminator) {
+    case "project_opened":
+    case "project_removed":
+    case "sidebar_project_order_set":
+      return 0
+    case "chat_created":
+      return 1
+    case "chat_renamed":
+    case "chat_provider_set":
+    case "chat_plan_mode_set":
+      return 2
+    case "message_appended":
+      return 3
+    case "queued_message_enqueued":
+    case "queued_message_removed":
+      return 4
+    case "turn_started":
+      return 5
+    case "session_token_set":
+    case "session_commands_loaded":
+      return 6
+    case "pending_fork_session_token_set":
+      return 6
+    case "turn_cancelled":
+      return 7
+    case "turn_finished":
+    case "turn_failed":
+      return 8
+    case "chat_read_state_set":
+    case "chat_source_hash_set":
+      return 9
+    case "chat_deleted":
+    case "chat_archived":
+    case "chat_unarchived":
+      return 10
+    case "auto_continue_proposed":
+    case "auto_continue_accepted":
+    case "auto_continue_rescheduled":
+    case "auto_continue_cancelled":
+    case "auto_continue_fired":
+      return 11
+  }
+}
+
+function encodeHistoryCursor(index: number) {
+  return `idx:${index}`
+}
+
+function decodeCursor(cursor: string) {
+  if (cursor.startsWith("idx:")) {
+    const value = Number.parseInt(cursor.slice("idx:".length), 10)
+    if (!Number.isInteger(value) || value < 0) {
+      throw new Error("Invalid history cursor")
+    }
+    return value
+  }
+
+  throw new Error("Invalid history cursor")
+}
+
+function slashCommandsEqual(a: SlashCommand[], b: SlashCommand[]) {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i += 1) {
+    const ai = a[i]
+    const bi = b[i]
+    if (ai.name !== bi.name || ai.description !== bi.description || ai.argumentHint !== bi.argumentHint) {
+      return false
+    }
+  }
+  return true
+}
+
+function getHistorySnapshot(page: TranscriptPageResult, recentLimit: number): ChatHistorySnapshot {
+  return {
+    hasOlder: page.hasOlder,
+    olderCursor: page.olderCursor,
+    recentLimit,
+  }
+}
+
+function getForkedChatTitle(title: string) {
+  const trimmed = title.trim()
+  if (!trimmed) return "Fork: New Chat"
+  return trimmed.startsWith("Fork: ") ? trimmed : `Fork: ${trimmed}`
+}
+
+export class EventStore {
+  readonly dataDir: string
+  readonly state: StoreState = createEmptyState()
+  private writeChain = Promise.resolve()
+  private storageReset = false
+  private readonly snapshotPath: string
+  private readonly projectsLogPath: string
+  private readonly chatsLogPath: string
+  private readonly messagesLogPath: string
+  private readonly queuedMessagesLogPath: string
+  private readonly turnsLogPath: string
+  private readonly schedulesLogPath: string
+  private readonly tunnelLogPath: string
+  private readonly transcriptsDir: string
+  private readonly sidebarProjectOrderPath: string
+  private legacyMessagesByChatId = new Map<string, TranscriptEntry[]>()
+  private legacySidebarProjectOrder: string[] = []
+  private sidebarProjectOrder: string[] = []
+  private snapshotHasLegacyMessages = false
+  private cachedTranscript: { chatId: string; entries: TranscriptEntry[] } | null = null
+  private readonly tunnelEventsByChatId = new Map<string, CloudflareTunnelEvent[]>()
+
+  constructor(dataDir = getDataDir(homedir())) {
+    this.dataDir = dataDir
+    this.snapshotPath = path.join(this.dataDir, "snapshot.json")
+    this.projectsLogPath = path.join(this.dataDir, "projects.jsonl")
+    this.chatsLogPath = path.join(this.dataDir, "chats.jsonl")
+    this.messagesLogPath = path.join(this.dataDir, "messages.jsonl")
+    this.queuedMessagesLogPath = path.join(this.dataDir, "queued-messages.jsonl")
+    this.turnsLogPath = path.join(this.dataDir, "turns.jsonl")
+    this.schedulesLogPath = path.join(this.dataDir, "schedules.jsonl")
+    this.tunnelLogPath = path.join(this.dataDir, "tunnels.jsonl")
+    this.transcriptsDir = path.join(this.dataDir, "transcripts")
+    this.sidebarProjectOrderPath = path.join(this.dataDir, SIDEBAR_PROJECT_ORDER_FILE)
+  }
+
+  async initialize() {
+    await mkdir(this.dataDir, { recursive: true })
+    await mkdir(this.transcriptsDir, { recursive: true })
+    await this.ensureFile(this.projectsLogPath)
+    await this.ensureFile(this.chatsLogPath)
+    await this.ensureFile(this.messagesLogPath)
+    await this.ensureFile(this.queuedMessagesLogPath)
+    await this.ensureFile(this.turnsLogPath)
+    await this.ensureFile(this.schedulesLogPath)
+    await this.ensureFile(this.tunnelLogPath)
+    await this.loadSnapshot()
+    await this.replayLogs()
+    await this.loadTunnelEvents()
+    await this.loadSidebarProjectOrder()
+    if (!(await this.hasLegacyTranscriptData()) && await this.shouldCompact()) {
+      await this.compact()
+    }
+  }
+
+  private async ensureFile(filePath: string) {
+    const file = Bun.file(filePath)
+    if (!(await file.exists())) {
+      await Bun.write(filePath, "")
+    }
+  }
+
+  private async clearStorage() {
+    if (this.storageReset) return
+    this.storageReset = true
+    this.resetState()
+    this.clearLegacyTranscriptState()
+    await Promise.all([
+      Bun.write(this.snapshotPath, ""),
+      Bun.write(this.projectsLogPath, ""),
+      Bun.write(this.chatsLogPath, ""),
+      Bun.write(this.messagesLogPath, ""),
+      Bun.write(this.queuedMessagesLogPath, ""),
+      Bun.write(this.turnsLogPath, ""),
+      Bun.write(this.schedulesLogPath, ""),
+      Bun.write(this.tunnelLogPath, ""),
+    ])
+  }
+
+  private async loadSnapshot() {
+    const file = Bun.file(this.snapshotPath)
+    if (!(await file.exists())) return
+
+    try {
+      const text = await file.text()
+      if (!text.trim()) return
+      const parsed = JSON.parse(text) as SnapshotFile
+      if (parsed.v !== STORE_VERSION) {
+        console.warn(`${LOG_PREFIX} Resetting local chat history for store version ${STORE_VERSION}`)
+        await this.clearStorage()
+        return
+      }
+      for (const project of parsed.projects) {
+        this.state.projectsById.set(project.id, { ...project })
+        this.state.projectIdsByPath.set(project.localPath, project.id)
+      }
+      for (const chat of parsed.chats) {
+        this.state.chatsById.set(chat.id, {
+          ...chat,
+          unread: chat.unread ?? false,
+          pendingForkSessionToken: chat.pendingForkSessionToken ?? null,
+        })
+      }
+      this.legacySidebarProjectOrder = normalizeSidebarProjectOrder(parsed.sidebarProjectOrder)
+      if (parsed.queuedMessages?.length) {
+        for (const queuedSet of parsed.queuedMessages) {
+          this.state.queuedMessagesByChatId.set(queuedSet.chatId, queuedSet.entries.map((entry) => ({
+            ...entry,
+            attachments: [...entry.attachments],
+          })))
+        }
+      }
+      if (parsed.messages?.length) {
+        this.snapshotHasLegacyMessages = true
+        for (const messageSet of parsed.messages) {
+          this.legacyMessagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
+        }
+      }
+      if (parsed.autoContinueEvents?.length) {
+        for (const entry of parsed.autoContinueEvents) {
+          this.state.autoContinueEventsByChatId.set(entry.chatId, [...entry.events])
+        }
+      }
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, error)
+      await this.clearStorage()
+    }
+  }
+
+  private resetState() {
+    this.state.projectsById.clear()
+    this.state.projectIdsByPath.clear()
+    this.state.chatsById.clear()
+    this.state.queuedMessagesByChatId.clear()
+    this.state.sidebarProjectOrder = []
+    this.state.autoContinueEventsByChatId.clear()
+    this.tunnelEventsByChatId.clear()
+    this.sidebarProjectOrder = []
+    this.legacySidebarProjectOrder = []
+    this.cachedTranscript = null
+  }
+
+  private clearLegacyTranscriptState() {
+    this.legacyMessagesByChatId.clear()
+    this.snapshotHasLegacyMessages = false
+  }
+
+  private async loadSidebarProjectOrder() {
+    const file = Bun.file(this.sidebarProjectOrderPath)
+    if (await file.exists()) {
+      try {
+        const text = await file.text()
+        if (!text.trim()) {
+          this.sidebarProjectOrder = []
+          return
+        }
+        this.sidebarProjectOrder = normalizeSidebarProjectOrder(JSON.parse(text))
+      } catch (error) {
+        console.warn(`${LOG_PREFIX} Failed to load ${SIDEBAR_PROJECT_ORDER_FILE}, ignoring saved order:`, error)
+        this.sidebarProjectOrder = []
+      }
+      return
+    }
+
+    const legacySidebarProjectOrder = await this.loadLegacySidebarProjectOrder()
+    this.sidebarProjectOrder = legacySidebarProjectOrder
+    if (legacySidebarProjectOrder.length > 0) {
+      await this.writeSidebarProjectOrderFile(legacySidebarProjectOrder)
+    }
+  }
+
+  private async loadLegacySidebarProjectOrder() {
+    const fromProjectsLog = await this.readLegacySidebarProjectOrderFromProjectsLog()
+    if (fromProjectsLog.length > 0) {
+      return fromProjectsLog
+    }
+    return [...this.legacySidebarProjectOrder]
+  }
+
+  private async readLegacySidebarProjectOrderFromProjectsLog() {
+    const file = Bun.file(this.projectsLogPath)
+    if (!(await file.exists())) return []
+
+    const text = await file.text()
+    if (!text.trim()) return []
+
+    const lines = text.split("\n")
+    let lastNonEmpty = -1
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      if (lines[index].trim()) {
+        lastNonEmpty = index
+        break
+      }
+    }
+
+    let projectIds: string[] = []
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index].trim()
+      if (!line) continue
+      try {
+        const event = JSON.parse(line) as {
+          v?: number
+          type?: string
+          projectIds?: unknown
+        }
+        if (event.v !== STORE_VERSION || event.type !== "sidebar_project_order_set") {
+          continue
+        }
+        projectIds = normalizeSidebarProjectOrder(event.projectIds)
+      } catch (error) {
+        if (index === lastNonEmpty) {
+          console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(this.projectsLogPath)} while migrating sidebar order`)
+          return projectIds
+        }
+        console.warn(`${LOG_PREFIX} Failed to migrate sidebar order from ${path.basename(this.projectsLogPath)}:`, error)
+        return []
+      }
+    }
+
+    return projectIds
+  }
+
+  private async writeSidebarProjectOrderFile(projectIds: string[]) {
+    await mkdir(this.dataDir, { recursive: true })
+    await writeFile(this.sidebarProjectOrderPath, `${JSON.stringify(projectIds, null, 2)}\n`, "utf8")
+  }
+
+  private async replayLogs() {
+    if (this.storageReset) return
+    const replayEvents = [
+      ...await this.loadReplayEvents(this.projectsLogPath, 0),
+      ...await this.loadReplayEvents(this.chatsLogPath, 1),
+      ...await this.loadReplayEvents(this.messagesLogPath, 2),
+      ...await this.loadReplayEvents(this.queuedMessagesLogPath, 3),
+      ...await this.loadReplayEvents(this.turnsLogPath, 4),
+      ...await this.loadReplayEvents(this.schedulesLogPath, 5),
+    ]
+    if (this.storageReset) return
+
+    replayEvents
+      .sort((left, right) => (
+        left.event.timestamp - right.event.timestamp
+        || getReplayEventPriority(left.event) - getReplayEventPriority(right.event)
+        || left.sourceIndex - right.sourceIndex
+        || left.lineIndex - right.lineIndex
+      ))
+      .forEach(({ event }) => {
+        this.applyEvent(event)
+      })
+  }
+
+  private async loadReplayEvents(filePath: string, sourceIndex: number): Promise<ParsedReplayEvent[]> {
+    const file = Bun.file(filePath)
+    if (!(await file.exists())) return []
+    const text = await file.text()
+    if (!text.trim()) return []
+
+    const parsedEvents: ParsedReplayEvent[] = []
+    const lines = text.split("\n")
+    let lastNonEmpty = -1
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      if (lines[index].trim()) {
+        lastNonEmpty = index
+        break
+      }
+    }
+
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index].trim()
+      if (!line) continue
+      try {
+        const event = JSON.parse(line) as Partial<StoreEvent>
+        if (event.v !== STORE_VERSION) {
+          console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
+          await this.clearStorage()
+          return []
+        }
+        if ((event as { type?: unknown }).type === "sidebar_project_order_set") {
+          continue
+        }
+        parsedEvents.push({
+          event: event as StoreEvent,
+          sourceIndex,
+          lineIndex: index,
+        })
+      } catch (error) {
+        if (index === lastNonEmpty) {
+          console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
+          return parsedEvents
+        }
+        console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
+        await this.clearStorage()
+        return []
+      }
+    }
+
+    return parsedEvents
+  }
+
+  private applyEvent(event: StoreEvent) {
+    if ("kind" in event) {
+      this.applyAutoContinueEvent(event)
+      return
+    }
+    const e = event as Exclude<StoreEvent, AutoContinueEvent>
+    switch (e.type) {
+      case "project_opened": {
+        const localPath = resolveLocalPath(e.localPath)
+        const project = {
+          id: e.projectId,
+          localPath,
+          title: e.title,
+          createdAt: e.timestamp,
+          updatedAt: e.timestamp,
+        }
+        this.state.projectsById.set(project.id, project)
+        this.state.projectIdsByPath.set(localPath, project.id)
+        break
+      }
+      case "project_removed": {
+        const project = this.state.projectsById.get(e.projectId)
+        if (!project) break
+        project.deletedAt = e.timestamp
+        project.updatedAt = e.timestamp
+        this.state.projectIdsByPath.delete(project.localPath)
+        break
+      }
+      case "sidebar_project_order_set": {
+        this.state.sidebarProjectOrder = [...e.projectIds]
+        break
+      }
+      case "chat_created": {
+      const chat = {
+          id: e.chatId,
+          projectId: e.projectId,
+          title: e.title,
+          createdAt: e.timestamp,
+          updatedAt: e.timestamp,
+          unread: false,
+          provider: null,
+          planMode: false,
+          sessionToken: null,
+          sourceHash: null,
+          pendingForkSessionToken: null,
+          hasMessages: false,
+          lastTurnOutcome: null,
+        }
+        this.state.chatsById.set(chat.id, chat)
+        break
+      }
+      case "chat_renamed": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.title = e.title
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_deleted": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.deletedAt = e.timestamp
+        chat.updatedAt = e.timestamp
+        this.state.queuedMessagesByChatId.delete(e.chatId)
+        this.state.autoContinueEventsByChatId.delete(e.chatId)
+        break
+      }
+      case "chat_archived": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.archivedAt = e.timestamp
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_unarchived": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        delete chat.archivedAt
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_provider_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.provider = e.provider
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_plan_mode_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.planMode = e.planMode
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_read_state_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.unread = e.unread
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "chat_source_hash_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.sourceHash = e.sourceHash
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "message_appended": {
+        this.applyMessageMetadata(e.chatId, e.entry)
+        const existing = this.legacyMessagesByChatId.get(e.chatId) ?? []
+        existing.push({ ...e.entry })
+        this.legacyMessagesByChatId.set(e.chatId, existing)
+        break
+      }
+      case "queued_message_enqueued": {
+        const existing = this.state.queuedMessagesByChatId.get(e.chatId) ?? []
+        existing.push({
+          ...e.message,
+          attachments: [...e.message.attachments],
+        })
+        this.state.queuedMessagesByChatId.set(e.chatId, existing)
+        const chat = this.state.chatsById.get(e.chatId)
+        if (chat) {
+          chat.updatedAt = e.timestamp
+        }
+        break
+      }
+      case "queued_message_removed": {
+        const existing = this.state.queuedMessagesByChatId.get(e.chatId) ?? []
+        const next = existing.filter((entry) => entry.id !== e.queuedMessageId)
+        if (next.length > 0) {
+          this.state.queuedMessagesByChatId.set(e.chatId, next)
+        } else {
+          this.state.queuedMessagesByChatId.delete(e.chatId)
+        }
+        const chat = this.state.chatsById.get(e.chatId)
+        if (chat) {
+          chat.updatedAt = e.timestamp
+        }
+        break
+      }
+      case "turn_started": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "turn_finished": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.updatedAt = e.timestamp
+        chat.unread = true
+        chat.lastTurnOutcome = "success"
+        break
+      }
+      case "turn_failed": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.updatedAt = e.timestamp
+        chat.unread = true
+        chat.lastTurnOutcome = "failed"
+        break
+      }
+      case "turn_cancelled": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.updatedAt = e.timestamp
+        chat.lastTurnOutcome = "cancelled"
+        break
+      }
+      case "session_token_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.sessionToken = e.sessionToken
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "session_commands_loaded": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.slashCommands = e.commands.map((c) => ({ ...c }))
+        chat.updatedAt = e.timestamp
+        break
+      }
+      case "pending_fork_session_token_set": {
+        const chat = this.state.chatsById.get(e.chatId)
+        if (!chat) break
+        chat.pendingForkSessionToken = e.pendingForkSessionToken
+        chat.updatedAt = e.timestamp
+        break
+      }
+    }
+  }
+
+  private applyAutoContinueEvent(event: AutoContinueEvent) {
+    const existing = this.state.autoContinueEventsByChatId.get(event.chatId) ?? []
+    existing.push(event)
+    this.state.autoContinueEventsByChatId.set(event.chatId, existing)
+  }
+
+  private applyMessageMetadata(chatId: string, entry: TranscriptEntry) {
+    const chat = this.state.chatsById.get(chatId)
+    if (!chat) return
+    chat.hasMessages = true
+    if (entry.kind === "user_prompt") {
+      chat.lastMessageAt = entry.createdAt
+    }
+    chat.updatedAt = Math.max(chat.updatedAt, entry.createdAt)
+  }
+
+  private append<TEvent extends StoreEvent>(filePath: string, event: TEvent) {
+    const payload = `${JSON.stringify(event)}\n`
+    this.writeChain = this.writeChain.then(async () => {
+      await appendFile(filePath, payload, "utf8")
+      this.applyEvent(event)
+    })
+    return this.writeChain
+  }
+
+  private transcriptPath(chatId: string) {
+    return path.join(this.transcriptsDir, `${chatId}.jsonl`)
+  }
+
+  private loadTranscriptFromDisk(chatId: string) {
+    const transcriptPath = this.transcriptPath(chatId)
+    if (!existsSync(transcriptPath)) {
+      return []
+    }
+
+    const text = readFileSyncImmediate(transcriptPath, "utf8")
+    if (!text.trim()) return []
+
+    const entries: TranscriptEntry[] = []
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.trim()
+      if (!line) continue
+      entries.push(JSON.parse(line) as TranscriptEntry)
+    }
+    return entries
+  }
+
+  async openProject(localPath: string, title?: string) {
+    const normalized = resolveLocalPath(localPath)
+    const existingId = this.state.projectIdsByPath.get(normalized)
+    if (existingId) {
+      const existing = this.state.projectsById.get(existingId)
+      if (existing && !existing.deletedAt) {
+        return existing
+      }
+    }
+
+    const hiddenProject = [...this.state.projectsById.values()]
+      .find((project) => project.localPath === normalized && project.deletedAt)
+    const projectId = hiddenProject?.id ?? crypto.randomUUID()
+    const event: ProjectEvent = {
+      v: STORE_VERSION,
+      type: "project_opened",
+      timestamp: Date.now(),
+      projectId,
+      localPath: normalized,
+      title: title?.trim() || path.basename(normalized) || normalized,
+    }
+    await this.append(this.projectsLogPath, event)
+    return this.state.projectsById.get(projectId)!
+  }
+
+  async removeProject(projectId: string) {
+    const project = this.getProject(projectId)
+    if (!project) {
+      throw new Error("Project not found")
+    }
+
+    const event: ProjectEvent = {
+      v: STORE_VERSION,
+      type: "project_removed",
+      timestamp: Date.now(),
+      projectId,
+    }
+    await this.append(this.projectsLogPath, event)
+  }
+
+  async setSidebarProjectOrder(projectIds: string[]) {
+    const validProjectIds = projectIds.filter((projectId) => {
+      const project = this.state.projectsById.get(projectId)
+      return Boolean(project && !project.deletedAt)
+    })
+
+    const uniqueProjectIds = [...new Set(validProjectIds)]
+    const current = this.sidebarProjectOrder
+    if (
+      uniqueProjectIds.length === current.length
+      && uniqueProjectIds.every((projectId, index) => current[index] === projectId)
+    ) {
+      return
+    }
+
+    this.writeChain = this.writeChain.then(async () => {
+      await this.writeSidebarProjectOrderFile(uniqueProjectIds)
+      this.sidebarProjectOrder = [...uniqueProjectIds]
+    })
+    return this.writeChain
+  }
+
+  async createChat(projectId: string) {
+    const project = this.state.projectsById.get(projectId)
+    if (!project || project.deletedAt) {
+      throw new Error("Project not found")
+    }
+    const chatId = crypto.randomUUID()
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_created",
+      timestamp: Date.now(),
+      chatId,
+      projectId,
+      title: "New Chat",
+    }
+    await this.append(this.chatsLogPath, event)
+    return this.state.chatsById.get(chatId)!
+  }
+
+  async forkChat(sourceChatId: string) {
+    const sourceChat = this.requireChat(sourceChatId)
+    const sourceSessionToken = sourceChat.sessionToken ?? sourceChat.pendingForkSessionToken ?? null
+    if (!sourceChat.provider || !sourceSessionToken) {
+      throw new Error("Chat cannot be forked")
+    }
+
+    const chatId = crypto.randomUUID()
+    const createdAt = Date.now()
+    const createEvent: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_created",
+      timestamp: createdAt,
+      chatId,
+      projectId: sourceChat.projectId,
+      title: getForkedChatTitle(sourceChat.title),
+    }
+    await this.append(this.chatsLogPath, createEvent)
+    await this.setChatProvider(chatId, sourceChat.provider)
+    await this.setPlanMode(chatId, sourceChat.planMode)
+    await this.setPendingForkSessionToken(chatId, sourceSessionToken)
+
+    const sourceEntries = this.getMessages(sourceChatId)
+    if (sourceEntries.length > 0) {
+      const transcriptPath = this.transcriptPath(chatId)
+      const payload = sourceEntries.map((entry) => JSON.stringify(entry)).join("\n")
+      this.writeChain = this.writeChain.then(async () => {
+        await mkdir(this.transcriptsDir, { recursive: true })
+        await writeFile(transcriptPath, `${payload}\n`, "utf8")
+        const chat = this.state.chatsById.get(chatId)
+        if (chat) {
+          chat.hasMessages = true
+          chat.updatedAt = Math.max(chat.updatedAt, createdAt)
+        }
+        if (this.cachedTranscript?.chatId === chatId) {
+          this.cachedTranscript = { chatId, entries: cloneTranscriptEntries(sourceEntries) }
+        }
+      })
+      await this.writeChain
+    }
+
+    return this.state.chatsById.get(chatId)!
+  }
+
+  async renameChat(chatId: string, title: string) {
+    const trimmed = title.trim()
+    if (!trimmed) return
+    const chat = this.requireChat(chatId)
+    if (chat.title === trimmed) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_renamed",
+      timestamp: Date.now(),
+      chatId,
+      title: trimmed,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async deleteChat(chatId: string) {
+    this.requireChat(chatId)
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_deleted",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async archiveChat(chatId: string) {
+    this.requireChat(chatId)
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_archived",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async unarchiveChat(chatId: string) {
+    this.requireChat(chatId)
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_unarchived",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async pruneStaleEmptyChats(args?: {
+    now?: number
+    maxAgeMs?: number
+    activeChatIds?: Iterable<string>
+    protectedChatIds?: Iterable<string>
+  }) {
+    const now = args?.now ?? Date.now()
+    const maxAgeMs = args?.maxAgeMs ?? STALE_EMPTY_CHAT_MAX_AGE_MS
+    const protectedChatIds = new Set([
+      ...(args?.activeChatIds ?? []),
+      ...(args?.protectedChatIds ?? []),
+    ])
+    const prunedChatIds: string[] = []
+
+    for (const chat of this.state.chatsById.values()) {
+      if (chat.deletedAt || chat.archivedAt || protectedChatIds.has(chat.id)) continue
+      if (now - chat.createdAt < maxAgeMs) continue
+      if (chat.hasMessages) continue
+      if (this.getMessages(chat.id).length > 0) {
+        chat.hasMessages = true
+        continue
+      }
+
+      const event: ChatEvent = {
+        v: STORE_VERSION,
+        type: "chat_deleted",
+        timestamp: now,
+        chatId: chat.id,
+      }
+      await this.append(this.chatsLogPath, event)
+
+      const transcriptPath = this.transcriptPath(chat.id)
+      await rm(transcriptPath, { force: true })
+      if (this.cachedTranscript?.chatId === chat.id) {
+        this.cachedTranscript = null
+      }
+
+      prunedChatIds.push(chat.id)
+    }
+
+    return prunedChatIds
+  }
+
+  async setChatProvider(chatId: string, provider: AgentProvider) {
+    const chat = this.requireChat(chatId)
+    if (chat.provider === provider) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_provider_set",
+      timestamp: Date.now(),
+      chatId,
+      provider,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async setPlanMode(chatId: string, planMode: boolean) {
+    const chat = this.requireChat(chatId)
+    if (chat.planMode === planMode) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_plan_mode_set",
+      timestamp: Date.now(),
+      chatId,
+      planMode,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async setChatReadState(chatId: string, unread: boolean) {
+    const chat = this.requireChat(chatId)
+    if (chat.unread === unread) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_read_state_set",
+      timestamp: Date.now(),
+      chatId,
+      unread,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  async appendMessage(chatId: string, entry: TranscriptEntry) {
+    this.requireChat(chatId)
+    const payload = `${JSON.stringify(entry)}\n`
+    const transcriptPath = this.transcriptPath(chatId)
+    const queuedAt = performance.now()
+    this.writeChain = this.writeChain.then(async () => {
+      const startedAt = performance.now()
+      const queueDelayMs = Number((startedAt - queuedAt).toFixed(1))
+      await mkdir(this.transcriptsDir, { recursive: true })
+      const beforeAppendAt = performance.now()
+      await appendFile(transcriptPath, payload, "utf8")
+      const afterAppendAt = performance.now()
+      this.applyMessageMetadata(chatId, entry)
+      if (this.cachedTranscript?.chatId === chatId) {
+        this.cachedTranscript.entries.push({ ...entry })
+      }
+      logSendToStartingProfile("event_store.append_message", {
+        chatId,
+        entryId: entry._id,
+        kind: entry.kind,
+        payloadBytes: payload.length,
+        queueDelayMs,
+        appendMs: Number((afterAppendAt - beforeAppendAt).toFixed(1)),
+        totalMs: Number((afterAppendAt - queuedAt).toFixed(1)),
+      })
+    })
+    return this.writeChain
+  }
+
+  async enqueueMessage(chatId: string, message: Omit<QueuedChatMessage, "id" | "createdAt"> & Partial<Pick<QueuedChatMessage, "id" | "createdAt">>) {
+    this.requireChat(chatId)
+    const queuedMessage: QueuedChatMessage = {
+      id: message.id ?? crypto.randomUUID(),
+      content: message.content,
+      attachments: [...(message.attachments ?? [])],
+      createdAt: message.createdAt ?? Date.now(),
+      provider: message.provider,
+      model: message.model,
+      modelOptions: message.modelOptions,
+      planMode: message.planMode,
+      autoContinue: message.autoContinue,
+    }
+    const event: QueuedMessageEvent = {
+      v: STORE_VERSION,
+      type: "queued_message_enqueued",
+      timestamp: queuedMessage.createdAt,
+      chatId,
+      message: queuedMessage,
+    }
+    await this.append(this.queuedMessagesLogPath, event)
+    return queuedMessage
+  }
+
+  async removeQueuedMessage(chatId: string, queuedMessageId: string) {
+    this.requireChat(chatId)
+    const existing = this.getQueuedMessages(chatId)
+    if (!existing.some((entry) => entry.id === queuedMessageId)) {
+      throw new Error("Queued message not found")
+    }
+    const event: QueuedMessageEvent = {
+      v: STORE_VERSION,
+      type: "queued_message_removed",
+      timestamp: Date.now(),
+      chatId,
+      queuedMessageId,
+    }
+    await this.append(this.queuedMessagesLogPath, event)
+  }
+
+  async recordTurnStarted(chatId: string) {
+    this.requireChat(chatId)
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "turn_started",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async recordTurnFinished(chatId: string) {
+    this.requireChat(chatId)
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "turn_finished",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async recordTurnFailed(chatId: string, error: string) {
+    this.requireChat(chatId)
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "turn_failed",
+      timestamp: Date.now(),
+      chatId,
+      error,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async recordTurnCancelled(chatId: string) {
+    this.requireChat(chatId)
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "turn_cancelled",
+      timestamp: Date.now(),
+      chatId,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async setSessionToken(chatId: string, sessionToken: string | null) {
+    const chat = this.requireChat(chatId)
+    if (chat.sessionToken === sessionToken) return
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "session_token_set",
+      timestamp: Date.now(),
+      chatId,
+      sessionToken,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async recordSessionCommandsLoaded(chatId: string, commands: SlashCommand[]) {
+    const chat = this.requireChat(chatId)
+    const normalized = commands.map((c) => ({
+      name: c.name,
+      description: c.description,
+      argumentHint: c.argumentHint,
+    }))
+    if (chat.slashCommands && slashCommandsEqual(chat.slashCommands, normalized)) {
+      return
+    }
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "session_commands_loaded",
+      timestamp: Date.now(),
+      chatId,
+      commands: normalized,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async setPendingForkSessionToken(chatId: string, pendingForkSessionToken: string | null) {
+    const chat = this.requireChat(chatId)
+    if ((chat.pendingForkSessionToken ?? null) === pendingForkSessionToken) return
+    const event: TurnEvent = {
+      v: STORE_VERSION,
+      type: "pending_fork_session_token_set",
+      timestamp: Date.now(),
+      chatId,
+      pendingForkSessionToken,
+    }
+    await this.append(this.turnsLogPath, event)
+  }
+
+  async setSourceHash(chatId: string, sourceHash: string | null) {
+    const chat = this.requireChat(chatId)
+    if (chat.sourceHash === sourceHash) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_source_hash_set",
+      timestamp: Date.now(),
+      chatId,
+      sourceHash,
+    }
+    await this.append(this.chatsLogPath, event)
+  }
+
+  getProject(projectId: string) {
+    const project = this.state.projectsById.get(projectId)
+    if (!project || project.deletedAt) return null
+    return project
+  }
+
+  requireChat(chatId: string) {
+    const chat = this.state.chatsById.get(chatId)
+    if (!chat || chat.deletedAt) {
+      throw new Error("Chat not found")
+    }
+    return chat
+  }
+
+  getChat(chatId: string) {
+    const chat = this.state.chatsById.get(chatId)
+    if (!chat || chat.deletedAt) return null
+    return chat
+  }
+
+  getSidebarProjectOrder() {
+    return [...this.sidebarProjectOrder]
+  }
+
+  private getMessagesPageFromEntries(entries: TranscriptEntry[], limit: number, beforeIndex?: number): TranscriptPageResult {
+    if (entries.length === 0) {
+      return { entries: [], hasOlder: false, olderCursor: null }
+    }
+
+    const endIndex = beforeIndex === undefined ? entries.length : Math.max(0, Math.min(beforeIndex, entries.length))
+    const startIndex = Math.max(0, endIndex - limit)
+    return {
+      entries: cloneTranscriptEntries(entries.slice(startIndex, endIndex)),
+      hasOlder: startIndex > 0,
+      olderCursor: startIndex > 0 ? encodeHistoryCursor(startIndex) : null,
+    }
+  }
+
+  getMessages(chatId: string) {
+    if (this.cachedTranscript?.chatId === chatId) {
+      return cloneTranscriptEntries(this.cachedTranscript.entries)
+    }
+
+    const legacyEntries = this.legacyMessagesByChatId.get(chatId)
+    if (legacyEntries) {
+      this.cachedTranscript = { chatId, entries: cloneTranscriptEntries(legacyEntries) }
+      return cloneTranscriptEntries(this.cachedTranscript.entries)
+    }
+
+    const entries = this.loadTranscriptFromDisk(chatId)
+    this.cachedTranscript = { chatId, entries }
+    return cloneTranscriptEntries(entries)
+  }
+
+  getQueuedMessages(chatId: string) {
+    const entries = this.state.queuedMessagesByChatId.get(chatId) ?? []
+    return entries.map((entry) => ({
+      ...entry,
+      attachments: [...entry.attachments],
+    }))
+  }
+
+  getQueuedMessage(chatId: string, queuedMessageId: string) {
+    return this.getQueuedMessages(chatId).find((entry) => entry.id === queuedMessageId) ?? null
+  }
+
+  getRecentMessagesPage(chatId: string, limit: number): ChatHistoryPage {
+    if (limit <= 0) {
+      return { messages: [], hasOlder: false, olderCursor: null }
+    }
+
+    const entries = this.getMessages(chatId)
+    const page = this.getMessagesPageFromEntries(entries, limit)
+
+    return {
+      messages: page.entries,
+      hasOlder: page.hasOlder,
+      olderCursor: page.olderCursor,
+    }
+  }
+
+  getMessagesPageBefore(chatId: string, beforeCursor: string, limit: number): ChatHistoryPage {
+    if (limit <= 0) {
+      return { messages: [], hasOlder: false, olderCursor: null }
+    }
+
+    const beforeIndex = decodeCursor(beforeCursor)
+    const entries = this.getMessages(chatId)
+    const page = this.getMessagesPageFromEntries(entries, limit, beforeIndex)
+
+    return {
+      messages: page.entries,
+      hasOlder: page.hasOlder,
+      olderCursor: page.olderCursor,
+    }
+  }
+
+  getRecentChatHistory(chatId: string, recentLimit: number) {
+    const page = this.getRecentMessagesPage(chatId, recentLimit)
+    return {
+      messages: page.messages,
+      history: getHistorySnapshot({
+        entries: page.messages,
+        hasOlder: page.hasOlder,
+        olderCursor: page.olderCursor,
+      }, recentLimit),
+    }
+  }
+
+  listProjects() {
+    return [...this.state.projectsById.values()].filter((project) => !project.deletedAt)
+  }
+
+  listChatsByProject(projectId: string) {
+    return [...this.state.chatsById.values()]
+      .filter((chat) => chat.projectId === projectId && !chat.deletedAt && !chat.archivedAt)
+      .sort((a, b) => (b.lastMessageAt ?? b.updatedAt) - (a.lastMessageAt ?? a.updatedAt))
+  }
+
+  getChatCount(projectId: string) {
+    return this.listChatsByProject(projectId).length
+  }
+
+  async getLegacyTranscriptStats(): Promise<LegacyTranscriptStats> {
+    const messagesLogSize = await Bun.file(this.messagesLogPath).size
+    const sources: LegacyTranscriptStats["sources"] = []
+    if (this.snapshotHasLegacyMessages) {
+      sources.push("snapshot")
+    }
+    if (messagesLogSize > 0) {
+      sources.push("messages_log")
+    }
+
+    let entryCount = 0
+    for (const entries of this.legacyMessagesByChatId.values()) {
+      entryCount += entries.length
+    }
+
+    return {
+      hasLegacyData: sources.length > 0 || this.legacyMessagesByChatId.size > 0,
+      sources,
+      chatCount: this.legacyMessagesByChatId.size,
+      entryCount,
+    }
+  }
+
+  async hasLegacyTranscriptData() {
+    return (await this.getLegacyTranscriptStats()).hasLegacyData
+  }
+
+  private createSnapshot(): SnapshotFile {
+    return {
+      v: STORE_VERSION,
+      generatedAt: Date.now(),
+      projects: this.listProjects().map((project) => ({ ...project })),
+      chats: [...this.state.chatsById.values()]
+        .filter((chat) => !chat.deletedAt)
+        .map((chat) => ({ ...chat })),
+      queuedMessages: [...this.state.queuedMessagesByChatId.entries()]
+        .map(([chatId, entries]) => ({
+          chatId,
+          entries: entries.map((entry) => ({
+            ...entry,
+            attachments: [...entry.attachments],
+          })),
+        })),
+      autoContinueEvents: [...this.state.autoContinueEventsByChatId.entries()].map(([chatId, events]) => ({
+        chatId,
+        events: [...events],
+      })),
+    }
+  }
+
+  async compact() {
+    const snapshot = this.createSnapshot()
+    await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
+    await Promise.all([
+      Bun.write(this.projectsLogPath, ""),
+      Bun.write(this.chatsLogPath, ""),
+      Bun.write(this.messagesLogPath, ""),
+      Bun.write(this.queuedMessagesLogPath, ""),
+      Bun.write(this.turnsLogPath, ""),
+      Bun.write(this.schedulesLogPath, ""),
+      // tunnels.jsonl is NOT compacted into the snapshot — it's left as-is
+      // so that active tunnel state survives server restarts.
+    ])
+  }
+
+  async migrateLegacyTranscripts(onProgress?: (message: string) => void) {
+    const stats = await this.getLegacyTranscriptStats()
+    if (!stats.hasLegacyData) return false
+
+    const sourceSummary = stats.sources.map((source) => source === "messages_log" ? "messages.jsonl" : "snapshot.json").join(", ")
+    onProgress?.(`${LOG_PREFIX} transcript migration detected: ${stats.chatCount} chats, ${stats.entryCount} entries from ${sourceSummary}`)
+
+    const messageSets = [...this.legacyMessagesByChatId.entries()]
+    onProgress?.(`${LOG_PREFIX} transcript migration: writing ${messageSets.length} per-chat transcript files`)
+
+    await mkdir(this.transcriptsDir, { recursive: true })
+    const logEveryChat = messageSets.length <= 10
+    for (let index = 0; index < messageSets.length; index += 1) {
+      const [chatId, entries] = messageSets[index]
+      const transcriptPath = this.transcriptPath(chatId)
+      const tempPath = `${transcriptPath}.tmp`
+      const payload = entries.map((entry) => JSON.stringify(entry)).join("\n")
+      await writeFile(tempPath, payload ? `${payload}\n` : "", "utf8")
+      await rename(tempPath, transcriptPath)
+      if (logEveryChat || (index + 1) % 25 === 0 || index === messageSets.length - 1) {
+        onProgress?.(`${LOG_PREFIX} transcript migration: ${index + 1}/${messageSets.length} chats`)
+      }
+    }
+
+    this.clearLegacyTranscriptState()
+    await this.compact()
+    this.cachedTranscript = null
+    onProgress?.(`${LOG_PREFIX} transcript migration complete`)
+    return true
+  }
+
+  private async shouldCompact() {
+    const sizes = await Promise.all([
+      Bun.file(this.projectsLogPath).size,
+      Bun.file(this.chatsLogPath).size,
+      Bun.file(this.messagesLogPath).size,
+      Bun.file(this.queuedMessagesLogPath).size,
+      Bun.file(this.turnsLogPath).size,
+      Bun.file(this.schedulesLogPath).size,
+    ])
+    return sizes.reduce((total, size) => total + size, 0) >= COMPACTION_THRESHOLD_BYTES
+  }
+
+  async appendAutoContinueEvent(event: AutoContinueEvent) {
+    return this.append(this.schedulesLogPath, event)
+  }
+
+  getAutoContinueEvents(chatId: string): AutoContinueEvent[] {
+    const list = this.state.autoContinueEventsByChatId.get(chatId)
+    return list ? [...list] : []
+  }
+
+  listAutoContinueChats(): string[] {
+    return [...this.state.autoContinueEventsByChatId.keys()]
+  }
+
+  async appendTunnelEvent(event: CloudflareTunnelEvent): Promise<void> {
+    const payload = `${JSON.stringify(event)}\n`
+    this.writeChain = this.writeChain.then(async () => {
+      await appendFile(this.tunnelLogPath, payload, "utf8")
+      this.applyTunnelEvent(event)
+    })
+    await this.writeChain
+  }
+
+  getTunnelEvents(chatId: string): CloudflareTunnelEvent[] {
+    const list = this.tunnelEventsByChatId.get(chatId)
+    return list ? [...list] : []
+  }
+
+  listTunnelChats(): string[] {
+    return [...this.tunnelEventsByChatId.keys()]
+  }
+
+  private applyTunnelEvent(event: CloudflareTunnelEvent): void {
+    const existing = this.tunnelEventsByChatId.get(event.chatId) ?? []
+    existing.push(event)
+    this.tunnelEventsByChatId.set(event.chatId, existing)
+  }
+
+  private async loadTunnelEvents(): Promise<void> {
+    const file = Bun.file(this.tunnelLogPath)
+    if (!(await file.exists())) return
+    const text = await file.text()
+    if (!text.trim()) return
+
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.trim()
+      if (!line) continue
+      try {
+        const event = JSON.parse(line) as CloudflareTunnelEvent
+        this.applyTunnelEvent(event)
+      } catch {
+        console.warn(`${LOG_PREFIX} Ignoring malformed line in tunnels.jsonl`)
+      }
+    }
+  }
+}