@cuongtran001/kanna 1.2.0 → 1.3.1

package/src/server/event-store.ts

@@ -1,260 +1,57 @@
 import { homedir } from "node:os"
 import path from "node:path"
-import { getDataDir, LOG_PREFIX } from "../shared/branding"
-import type { AnyValue } from "../shared/errors"
+import { getDataDir } from "../shared/branding"
 import { log } from "../shared/log"
 import type { StorageBackend } from "./storage/backend"
 import { FsStorageBackend } from "./storage/fs-storage.adapter"
-import type { AgentProvider, ChatHistoryPage, ChatHistorySnapshot, QueuedChatMessage, SlashCommand, StackBinding, SubagentRunSnapshot, TranscriptEntry } from "../shared/types"
-import { STORE_VERSION } from "../shared/types"
+import type { AgentProvider, ChatHistoryPage, QueuedChatMessage, SlashCommand, StackBinding, SubagentRunSnapshot, TranscriptEntry } from "../shared/types"
 import type { AutoContinueEvent } from "./auto-continue/events"
 import {
-  type ChatEvent,
-  type ChatRecord,
-  type ChatTimingState,
   type OrchestrationEvent,
-  type OrchRunRecord,
-  type OrchTaskRecord,
-  type ProjectEvent,
-  type QueuedMessageEvent,
-  type SnapshotFile,
-  type StackEvent,
   type StackRecord,
   type StoreEvent,
   type StoreState,
   type SubagentRunEvent,
-  type ToolRequestEvent,
-  type TurnEvent,
   type TurnRunConfig,
-  cloneTranscriptEntries,
   createEmptyState,
 } from "./events"
-import type { OrchRunSnapshot, OrchTaskSnapshot } from "../shared/orchestration-types"
-import { isTaskEventType, nextRunStatus, nextTaskState } from "./orchestration-state-machine"
+import type { OrchRunSnapshot } from "../shared/orchestration-types"
 import type { ChatPermissionPolicyOverride, ToolRequest, ToolRequestDecision, ToolRequestStatus } from "../shared/permission-policy"
-import { resolveLocalPath } from "./paths"
 import type { CloudflareTunnelEvent } from "./cloudflare-tunnel/events"
 import type { PushEvent, PushEventStore } from "./push/events"
 import type { ShareEvent } from "./session-share/share-projection"
-import { ACTIVE_SESSION_IDLE_GAP_MS } from "./read-models"
-import { capTranscriptEntry } from "./subagent-entry-cap.adapter"
+import {
+  getSubagentRuns as getSubagentRunsFromMap,
+  runningSubagentRuns as runningSubagentRunsFromMap,
+  appendSubagentEvent as appendSubagentEventFn,
+  type AppendSubagentDeps,
+} from "./event-store-subagent"
+import {
+  getToolRequest as getToolRequestFromMap,
+  listPendingToolRequests as listPendingToolRequestsFromMap,
+  scanAllToolRequests as scanAllToolRequestsFromMap,
+  putToolRequest as putToolRequestFn,
+  resolveToolRequest as resolveToolRequestFn,
+  type ToolRequestWriteDeps,
+} from "./event-store-tool-requests"
+import * as OrchSubscription from "./event-store-orch-subscription"
+import { applyStoreEvent } from "./event-store-apply"
+import * as PeripheralEvents from "./event-store-peripheral-events.adapter"
+import * as MessageRead from "./event-store-messages.adapter"
+import * as EntityWrite from "./event-store-entity-write"
+import * as TranscriptWrite from "./event-store-transcript-write.adapter"
+import {
+  initializeEventStore,
+  getLegacyTranscriptStats as getLegacyTranscriptStatsFn,
+  hasLegacyTranscriptData as hasLegacyTranscriptDataFn,
+  snapshotAndTruncateLogs as snapshotAndTruncateLogsFn,
+  migrateLegacyTranscripts as migrateLegacyTranscriptsFn,
+  type EventStoreInitDeps,
+  type LegacyTranscriptStats,
+} from "./event-store-init"
 
-const SNAPSHOT_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<T>(value: T) {
-  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
-  }
-
-  log.info("[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): number {
-  const discriminator = "type" in event ? event.type : event.kind
-  switch (discriminator) {
-    case "project_opened":
-    case "project_removed":
-    case "sidebar_project_order_set":
-    case "project_star_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":
-    case "chat_policy_override_set":
-    case "chat_compact_failures_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":
-    case "loop_armed":
-    case "loop_disarmed":
-      return 11
-    case "stack_added":
-    case "stack_removed":
-    case "stack_renamed":
-    case "stack_project_added":
-    case "stack_project_removed":
-      return 0
-    case "subagent_run_started":
-    case "subagent_message_delta":
-    case "subagent_entry_appended":
-    case "subagent_run_completed":
-    case "subagent_run_failed":
-    case "subagent_run_cancelled":
-    case "subagent_tool_pending":
-    case "subagent_tool_resolved":
-      return 5
-    // tool_request_put shares priority 5 with subagent_* events; sourceIndex
-    // tie-break orders them (tool-requests has sourceIndex 7, turns has 5).
-    case "tool_request_put":
-      return 5
-    case "tool_request_resolved":
-      return 6
-    case "orch_run_created":
-    case "orch_worktree_provisioned":
-    case "orch_worktree_init_started":
-    case "orch_worktree_init_completed":
-    case "orch_task_claimed":
-    case "orch_phase_started":
-    case "orch_phase_completed":
-    case "orch_gate_opened":
-    case "orch_gate_resolved":
-    case "orch_scope_overlap_flagged":
-    case "orch_config_warning":
-    case "orch_verify_started":
-    case "orch_verify_completed":
-    case "orch_task_committed":
-    case "orch_task_failed":
-    case "orch_task_requeued":
-    case "orch_run_completed":
-    case "orch_run_cancelled":
-      return 5
-    default: {
-      const _exhaustive: never = discriminator
-      throw new Error(`Unhandled replay event type: ${String(_exhaustive)}`)
-    }
-  }
-}
-
-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
-}
-
-// `context_window_updated` entries are token-readout noise emitted once per
-// stream tick — only the latest value matters. A single turn can emit hundreds
-// of them, and the bounded live window (getMessagesPageFromEntries) counts each
-// 1:1 against the limit, so a flood evicts real turns (e.g. the user_prompt)
-// out of the snapshot the client renders. Collapsing each maximal run of
-// consecutive cwu entries to its last entry keeps the latest readout while
-// freeing window budget for real turns. Applied only on the live-window read
-// path (not getMessages), so getLatestContextWindowUsage / full-transcript
-// export / importer still observe every persisted cwu.
-function coalesceContextWindowUpdates(entries: TranscriptEntry[]): TranscriptEntry[] {
-  const result: TranscriptEntry[] = []
-  for (let index = 0; index < entries.length; index += 1) {
-    const entry = entries[index]!
-    const next = entries[index + 1]
-    if (entry.kind === "context_window_updated" && next?.kind === "context_window_updated") {
-      // Drop this cwu; the last of the run survives.
-      continue
-    }
-    result.push(entry)
-  }
-  return result
-}
-
-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 implements PushEventStore {
   readonly dataDir: string
   readonly state: StoreState = createEmptyState()
@@ -283,9 +80,9 @@ export class EventStore implements PushEventStore {
   // --resume; on cold-wake the reader starts at byte 0 and would re-emit).
   private seenMessageIdsByChatId = new Map<string, Set<string>>()
   private legacySidebarProjectOrder: string[] = []
-  private sidebarProjectOrder: string[] = []
+  private readonly sidebarProjectOrderRef: { value: string[] } = { value: [] }
   private snapshotHasLegacyMessages = false
-  private cachedTranscript: { chatId: string; entries: TranscriptEntry[] } | null = null
+  private readonly cachedTranscriptRef: MessageRead.CachedTranscriptRef = { value: null }
   private readonly tunnelEventsByChatId = new Map<string, CloudflareTunnelEvent[]>()
   private shareEventsAll: ShareEvent[] = []
   private replayChatProvider = new Map<string, AgentProvider | null>()
@@ -313,786 +110,16 @@ export class EventStore implements PushEventStore {
   }
 
   async initialize() {
-    await this.storage.mkdir(this.dataDir)
-    await this.storage.mkdir(this.transcriptsDir)
-    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.ensureFile(this.sharesLogPath)
-    await this.ensureFile(this.pushLogPath)
-    await this.ensureFile(this.stacksLogPath)
-    await this.ensureFile(this.toolRequestsLogPath)
-    await this.ensureFile(this.orchLogPath)
-    await this.loadSnapshot()
-    await this.replayLogs()
-    await this.loadTunnelEvents()
-    await this.loadShareEvents()
-    await this.loadSidebarProjectOrder()
-    if (!(await this.hasLegacyTranscriptData()) && await this.shouldSnapshotLogs()) {
-      await this.snapshotAndTruncateLogs()
-    }
-  }
-
-  private async ensureFile(filePath: string) {
-    if (!(await this.storage.exists(filePath))) {
-      await this.storage.writeText(filePath, "")
-    }
-  }
-
-  private async clearStorage() {
-    if (this.storageReset) return
-    this.storageReset = true
-    this.resetState()
-    this.clearLegacyTranscriptState()
-    await Promise.all([
-      this.storage.writeText(this.snapshotPath, ""),
-      this.storage.writeText(this.projectsLogPath, ""),
-      this.storage.writeText(this.chatsLogPath, ""),
-      this.storage.writeText(this.messagesLogPath, ""),
-      this.storage.writeText(this.queuedMessagesLogPath, ""),
-      this.storage.writeText(this.turnsLogPath, ""),
-      this.storage.writeText(this.schedulesLogPath, ""),
-      this.storage.writeText(this.tunnelLogPath, ""),
-      this.storage.writeText(this.sharesLogPath, ""),
-      this.storage.writeText(this.stacksLogPath, ""),
-      this.storage.writeText(this.toolRequestsLogPath, ""),
-      this.storage.writeText(this.orchLogPath, ""),
-    ])
-  }
-
-  private async loadSnapshot() {
-    if (!(await this.storage.exists(this.snapshotPath))) return
-
-    try {
-      const text = await this.storage.readText(this.snapshotPath)
-      if (!text.trim()) return
-      const parsed: SnapshotFile = JSON.parse(text)
-      if (parsed.v !== STORE_VERSION) {
-        log.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) {
-        // Access legacy fields from old snapshot data via Reflect.get (avoids `as` casts).
-        const legacySessionToken: string | null | undefined = Reflect.get(chat, "sessionToken")
-        const legacyPendingFork: string | null | { provider: AgentProvider; token: string } | undefined = Reflect.get(chat, "pendingForkSessionToken")
-        const legacyTokensByProvider: Partial<Record<AgentProvider, string | null>> | undefined = Reflect.get(chat, "sessionTokensByProvider")
-
-        const sessionTokensByProvider: Partial<Record<AgentProvider, string | null>> =
-          legacyTokensByProvider ? { ...legacyTokensByProvider } : {}
-        if (
-          typeof legacySessionToken === "string"
-          && chat.provider
-          && sessionTokensByProvider[chat.provider] == null
-        ) {
-          sessionTokensByProvider[chat.provider] = legacySessionToken
-        }
-        let pendingForkSessionToken: ChatRecord["pendingForkSessionToken"] = null
-        if (legacyPendingFork && typeof legacyPendingFork === "object" && "token" in legacyPendingFork) {
-          pendingForkSessionToken = legacyPendingFork
-        } else if (typeof legacyPendingFork === "string" && chat.provider) {
-          pendingForkSessionToken = { provider: chat.provider, token: legacyPendingFork }
-        }
-        this.state.chatsById.set(chat.id, {
-          ...chat,
-          unread: chat.unread ?? false,
-          sessionTokensByProvider,
-          pendingForkSessionToken,
-        })
-      }
-      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])
-        }
-      }
-      if (parsed.stacks?.length) {
-        for (const stack of parsed.stacks) {
-          this.state.stacksById.set(stack.id, { ...stack, projectIds: [...stack.projectIds] })
-        }
-      }
-    } catch (error) {
-      log.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, String(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.state.stacksById.clear()
-    this.tunnelEventsByChatId.clear()
-    this.sidebarProjectOrder = []
-    this.legacySidebarProjectOrder = []
-    this.cachedTranscript = null
-  }
-
-  private clearLegacyTranscriptState() {
-    this.legacyMessagesByChatId.clear()
-    this.snapshotHasLegacyMessages = false
-  }
-
-  private async loadSidebarProjectOrder() {
-    if (await this.storage.exists(this.sidebarProjectOrderPath)) {
-      try {
-        const text = await this.storage.readText(this.sidebarProjectOrderPath)
-        if (!text.trim()) {
-          this.sidebarProjectOrder = []
-          return
-        }
-        this.sidebarProjectOrder = normalizeSidebarProjectOrder(JSON.parse(text))
-      } catch (error) {
-        log.warn(`${LOG_PREFIX} Failed to load ${SIDEBAR_PROJECT_ORDER_FILE}, ignoring saved order:`, String(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() {
-    if (!(await this.storage.exists(this.projectsLogPath))) return []
-
-    const text = await this.storage.readText(this.projectsLogPath)
-    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: { v?: number; type?: string; projectIds?: AnyValue } = JSON.parse(line)
-        if (event.v !== STORE_VERSION || event.type !== "sidebar_project_order_set") {
-          continue
-        }
-        projectIds = normalizeSidebarProjectOrder(event.projectIds)
-      } catch (error) {
-        if (index === lastNonEmpty) {
-          log.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(this.projectsLogPath)} while migrating sidebar order`)
-          return projectIds
-        }
-        log.warn(`${LOG_PREFIX} Failed to migrate sidebar order from ${path.basename(this.projectsLogPath)}:`, String(error))
-        return []
-      }
-    }
-
-    return projectIds
-  }
-
-  private async writeSidebarProjectOrderFile(projectIds: string[]) {
-    await this.storage.mkdir(this.dataDir)
-    await this.storage.writeText(this.sidebarProjectOrderPath, `${JSON.stringify(projectIds, null, 2)}\n`)
-  }
-
-  private async replayLogs() {
-    if (this.storageReset) return
-    const replayEvents = [
-      ...await this.loadReplayEvents(this.projectsLogPath, 0),
-      ...await this.loadReplayEvents(this.stacksLogPath, 1),
-      ...await this.loadReplayEvents(this.chatsLogPath, 2),
-      ...await this.loadReplayEvents(this.messagesLogPath, 3),
-      ...await this.loadReplayEvents(this.queuedMessagesLogPath, 4),
-      ...await this.loadReplayEvents(this.turnsLogPath, 5),
-      ...await this.loadReplayEvents(this.schedulesLogPath, 6),
-      ...await this.loadReplayEvents(this.toolRequestsLogPath, 7),
-      ...await this.loadReplayEvents(this.orchLogPath, 8),
-    ]
-    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)
-      })
-    this.replayChatProvider.clear()
-  }
-
-  private async loadReplayEvents(filePath: string, sourceIndex: number): Promise<ParsedReplayEvent[]> {
-    if (!(await this.storage.exists(filePath))) return []
-    const text = await this.storage.readText(filePath)
-    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: StoreEvent & { v?: number; type?: string } = JSON.parse(line)
-        if (event.v !== STORE_VERSION) {
-          log.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
-          await this.clearStorage()
-          return []
-        }
-        if (event.type === "sidebar_project_order_set") {
-          continue
-        }
-        parsedEvents.push({
-          event,
-          sourceIndex,
-          lineIndex: index,
-        })
-      } catch (error) {
-        if (index === lastNonEmpty) {
-          log.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
-          return parsedEvents
-        }
-        log.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, String(error))
-        await this.clearStorage()
-        return []
-      }
-    }
-
-    return parsedEvents
-  }
-
-  private applyEvent(event: StoreEvent) {
-    if ("kind" in event) {
-      this.applyAutoContinueEvent(event)
-      return
-    }
-    const e: Exclude<StoreEvent, AutoContinueEvent> = event
-    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 "project_star_set": {
-        const project = this.state.projectsById.get(e.projectId)
-        if (!project) break
-        if (e.starredAt == null) {
-          delete project.starredAt
-        } else {
-          project.starredAt = e.starredAt
-        }
-        project.updatedAt = e.timestamp
-        break
-      }
-      case "chat_created": {
-        const chat: ChatRecord = {
-          id: e.chatId,
-          projectId: e.projectId,
-          title: e.title,
-          createdAt: e.timestamp,
-          updatedAt: e.timestamp,
-          unread: false,
-          provider: null,
-          planMode: false,
-          sessionTokensByProvider: {},
-          sourceHash: null,
-          pendingForkSessionToken: null,
-          hasMessages: false,
-          lastTurnOutcome: null,
-        }
-        if (e.stackId !== undefined) chat.stackId = e.stackId
-        if (e.stackBindings !== undefined) chat.stackBindings = e.stackBindings.map((b) => ({ ...b }))
-        this.state.chatsById.set(chat.id, chat)
-        this.replayChatProvider.set(e.chatId, null)
-        this.state.subagentRunsByChatId.set(e.chatId, new Map())
-        this.updateTiming(e.chatId, e.timestamp, "idle")
-        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)
-        this.state.chatTimingsByChatId.delete(e.chatId)
-        this.state.subagentRunsByChatId.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
-        this.replayChatProvider.set(e.chatId, e.provider)
-        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 "chat_policy_override_set": {
-        const chat = this.state.chatsById.get(e.chatId)
-        if (!chat) break
-        chat.policyOverride = e.policyOverride
-        chat.updatedAt = e.timestamp
-        break
-      }
-      case "chat_compact_failures_set": {
-        const chat = this.state.chatsById.get(e.chatId)
-        if (!chat) break
-        chat.compactFailureCount = e.compactFailureCount
-        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
-        this.updateTiming(e.chatId, e.timestamp, "running", true, false)
-        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"
-        this.updateTiming(e.chatId, e.timestamp, "idle", false, true)
-        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"
-        this.updateTiming(e.chatId, e.timestamp, "failed", false, true)
-        break
-      }
-      case "turn_cancelled": {
-        const chat = this.state.chatsById.get(e.chatId)
-        if (!chat) break
-        chat.updatedAt = e.timestamp
-        chat.lastTurnOutcome = "cancelled"
-        this.updateTiming(e.chatId, e.timestamp, "idle", false, true)
-        break
-      }
-      case "session_token_set": {
-        const chat = this.state.chatsById.get(e.chatId)
-        if (!chat) break
-        const provider = e.provider ?? this.replayChatProvider.get(e.chatId) ?? chat.provider
-        if (!provider) break
-        chat.sessionTokensByProvider = {
-          ...chat.sessionTokensByProvider,
-          [provider]: 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
-        if (e.pendingForkSessionToken == null) {
-          chat.pendingForkSessionToken = null
-        } else {
-          const provider = e.provider ?? this.replayChatProvider.get(e.chatId) ?? chat.provider
-          if (!provider) break
-          chat.pendingForkSessionToken = { provider, token: e.pendingForkSessionToken }
-        }
-        chat.updatedAt = e.timestamp
-        break
-      }
-      case "stack_added": {
-        const record: StackRecord = {
-          id: e.stackId,
-          title: e.title,
-          projectIds: [...e.projectIds],
-          createdAt: e.timestamp,
-          updatedAt: e.timestamp,
-        }
-        this.state.stacksById.set(record.id, record)
-        break
-      }
-      case "stack_removed": {
-        const stack = this.state.stacksById.get(e.stackId)
-        if (!stack || stack.deletedAt) break
-        stack.deletedAt = e.timestamp
-        stack.updatedAt = e.timestamp
-        break
-      }
-      case "stack_renamed": {
-        const stack = this.state.stacksById.get(e.stackId)
-        if (!stack || stack.deletedAt) break
-        stack.title = e.title
-        stack.updatedAt = e.timestamp
-        break
-      }
-      case "stack_project_added": {
-        const stack = this.state.stacksById.get(e.stackId)
-        if (!stack || stack.deletedAt) break
-        if (stack.projectIds.includes(e.projectId)) break
-        stack.projectIds = [...stack.projectIds, e.projectId]
-        stack.updatedAt = e.timestamp
-        break
-      }
-      case "stack_project_removed": {
-        const stack = this.state.stacksById.get(e.stackId)
-        if (!stack || stack.deletedAt) break
-        const next = stack.projectIds.filter((id) => id !== e.projectId)
-        stack.projectIds = next
-        stack.updatedAt = e.timestamp
-        break
-      }
-      case "subagent_run_started": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        if (!map) break
-        map.set(e.runId, {
-          runId: e.runId,
-          chatId: e.chatId,
-          subagentId: e.subagentId,
-          subagentName: e.subagentName,
-          provider: e.provider,
-          model: e.model,
-          status: "running",
-          parentUserMessageId: e.parentUserMessageId,
-          parentRunId: e.parentRunId,
-          depth: e.depth,
-          startedAt: e.timestamp,
-          finishedAt: null,
-          finalText: null,
-          error: null,
-          usage: null,
-          entries: [],
-          pendingTool: null,
-        })
-        break
-      }
-      case "subagent_message_delta": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.finalText = (run.finalText ?? "") + e.content
-        break
-      }
-      case "subagent_entry_appended": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.entries.push(e.entry)
-        // If the entry carries usage (the SDK's terminal "result" message), mirror
-        // it onto run.usage so callers can read it without scanning entries.
-        if (e.entry.kind === "result") {
-          const usage = e.entry.usage
-          const cost = e.entry.costUsd
-          run.usage = {
-            inputTokens: usage?.inputTokens,
-            outputTokens: usage?.outputTokens,
-            cachedInputTokens: usage?.cachedInputTokens,
-            costUsd: cost,
-          }
-        }
-        break
-      }
-      case "subagent_run_completed": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.status = "completed"
-        run.finishedAt = e.timestamp
-        run.finalText = e.finalContent
-        // Merge: prefer e.usage if present, otherwise keep what subagent_entry_appended
-        // already mirrored. Otherwise null. Without this guard a streaming run
-        // whose completion event omits usage would silently erase it.
-        run.usage = e.usage ?? run.usage ?? null
-        break
-      }
-      case "subagent_run_failed": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.status = "failed"
-        run.finishedAt = e.timestamp
-        run.error = e.error
-        run.pendingTool = null
-        break
-      }
-      case "subagent_run_cancelled": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.status = "cancelled"
-        run.finishedAt = e.timestamp
-        run.pendingTool = null
-        break
-      }
-      case "subagent_tool_pending": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.pendingTool = {
-          toolUseId: e.toolUseId,
-          toolKind: e.toolKind,
-          input: e.input,
-          requestedAt: e.timestamp,
-        }
-        break
-      }
-      case "subagent_tool_resolved": {
-        const map = this.state.subagentRunsByChatId.get(e.chatId)
-        const run = map?.get(e.runId)
-        if (!run) break
-        run.pendingTool = null
-        const syntheticEntry: TranscriptEntry = {
-          kind: "tool_result",
-          _id: `${e.runId}:${e.toolUseId}:resolved`,
-          createdAt: e.timestamp,
-          toolId: e.toolUseId,
-          content: e.result,
-        }
-        run.entries.push(syntheticEntry)
-        break
-      }
-      case "tool_request_put": {
-        this.state.toolRequestsById.set(e.request.id, { ...e.request })
-        break
-      }
-      case "tool_request_resolved": {
-        const existing = this.state.toolRequestsById.get(e.id)
-        if (!existing) break
-        this.state.toolRequestsById.set(e.id, {
-          ...existing,
-          status: e.status,
-          decision: e.decision ?? existing.decision,
-          resolvedAt: e.resolvedAt,
-          mismatchReason: e.mismatchReason,
-        })
-        break
-      }
-      case "orch_run_created":
-      case "orch_worktree_provisioned":
-      case "orch_worktree_init_started":
-      case "orch_worktree_init_completed":
-      case "orch_task_claimed":
-      case "orch_phase_started":
-      case "orch_phase_completed":
-      case "orch_gate_opened":
-      case "orch_gate_resolved":
-      case "orch_scope_overlap_flagged":
-      case "orch_config_warning":
-      case "orch_verify_started":
-      case "orch_verify_completed":
-      case "orch_task_committed":
-      case "orch_task_failed":
-      case "orch_task_requeued":
-      case "orch_run_completed":
-      case "orch_run_cancelled":
-        this.applyOrchestrationEvent(e)
-        break
-    }
-  }
-
-  private updateTiming(chatId: string, eventTs: number, nextStatus: ChatTimingState["status"], onTurnStart?: boolean, onTurnFinish?: boolean) {
-    const prev = this.state.chatTimingsByChatId.get(chatId)
-    if (!prev) {
-      // chat_created path: seed
-      this.state.chatTimingsByChatId.set(chatId, {
-        status: nextStatus,
-        stateEnteredAt: eventTs,
-        activeSessionStartedAt: eventTs,
-        lastTurnStartedAt: null,
-        lastTurnDurationMs: null,
-        cumulativeMs: { idle: 0, starting: 0, running: 0, failed: 0 },
-      })
-      return
-    }
-
-    const segmentMs = Math.max(0, eventTs - prev.stateEnteredAt)
-    let activeSessionStartedAt = prev.activeSessionStartedAt
-    let cumulativeMs = { ...prev.cumulativeMs }
-
-    // Detect long idle gap when leaving idle -> something
-    if (prev.status === "idle" && nextStatus !== "idle" && segmentMs > ACTIVE_SESSION_IDLE_GAP_MS) {
-      activeSessionStartedAt = eventTs
-      cumulativeMs = { idle: 0, starting: 0, running: 0, failed: 0 }
-    } else {
-      cumulativeMs[prev.status] += segmentMs
-    }
-
-    let lastTurnStartedAt = prev.lastTurnStartedAt
-    let lastTurnDurationMs = prev.lastTurnDurationMs
-    if (onTurnStart) lastTurnStartedAt = eventTs
-    if (onTurnFinish && lastTurnStartedAt != null) lastTurnDurationMs = Math.max(0, eventTs - lastTurnStartedAt)
-
-    this.state.chatTimingsByChatId.set(chatId, {
-      status: nextStatus,
-      stateEnteredAt: eventTs,
-      activeSessionStartedAt,
-      lastTurnStartedAt,
-      lastTurnDurationMs,
-      cumulativeMs,
+    await initializeEventStore(this.buildInitDeps(), {
+      loadTunnelEvents: () => this.loadTunnelEvents(),
+      loadShareEvents: () => this.loadShareEvents(),
+      hasLegacyTranscriptData: () => this.hasLegacyTranscriptData(),
+      snapshotAndTruncateLogs: () => this.snapshotAndTruncateLogs(),
     })
   }
 
-  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 applyEvent(event: StoreEvent) {
+    applyStoreEvent(event, this.state, this.legacyMessagesByChatId, this.replayChatProvider)
   }
 
   private enqueueDiskAppend(filePath: string, payload: string): void {
@@ -1112,390 +139,192 @@ export class EventStore implements PushEventStore {
     return this.writeChain
   }
 
-  private transcriptPath(chatId: string) {
-    return path.join(this.transcriptsDir, `${chatId}.jsonl`)
-  }
-
-  private loadTranscriptFromDisk(chatId: string) {
-    const transcriptPath = this.transcriptPath(chatId)
-    if (!this.storage.existsSync(transcriptPath)) {
-      return []
-    }
+  // ─── Deps builders ──────────────────────────────────────────────────────────
 
-    const text = this.storage.readTextSync(transcriptPath)
-    if (!text.trim()) return []
-
-    const entries: TranscriptEntry[] = []
-    const seen = this.getSeenMessageIds(chatId)
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim()
-      if (!line) continue
-      const entry: TranscriptEntry & { messageId?: string } = JSON.parse(line)
-      entries.push(entry)
-      const mid = entry.messageId
-      if (typeof mid === "string" && mid.length > 0) {
-        seen.add(mid)
-      }
+  private buildInitDeps(): EventStoreInitDeps {
+    return {
+      storage: this.storage,
+      dataDir: this.dataDir,
+      snapshotPath: this.snapshotPath,
+      projectsLogPath: this.projectsLogPath,
+      chatsLogPath: this.chatsLogPath,
+      messagesLogPath: this.messagesLogPath,
+      queuedMessagesLogPath: this.queuedMessagesLogPath,
+      turnsLogPath: this.turnsLogPath,
+      schedulesLogPath: this.schedulesLogPath,
+      tunnelLogPath: this.tunnelLogPath,
+      sharesLogPath: this.sharesLogPath,
+      pushLogPath: this.pushLogPath,
+      stacksLogPath: this.stacksLogPath,
+      toolRequestsLogPath: this.toolRequestsLogPath,
+      orchLogPath: this.orchLogPath,
+      transcriptsDir: this.transcriptsDir,
+      sidebarProjectOrderPath: this.sidebarProjectOrderPath,
+      state: this.state,
+      legacyMessagesByChatId: this.legacyMessagesByChatId,
+      tunnelEventsByChatId: this.tunnelEventsByChatId,
+      cachedTranscriptRef: this.cachedTranscriptRef,
+      sidebarProjectOrderRef: this.sidebarProjectOrderRef,
+      getLegacySidebarProjectOrder: () => this.legacySidebarProjectOrder,
+      setLegacySidebarProjectOrder: (v) => { this.legacySidebarProjectOrder = v },
+      getSnapshotHasLegacyMessages: () => this.snapshotHasLegacyMessages,
+      setSnapshotHasLegacyMessages: (v) => { this.snapshotHasLegacyMessages = v },
+      getStorageReset: () => this.storageReset,
+      setStorageReset: (v) => { this.storageReset = v },
+      replayChatProvider: this.replayChatProvider,
+      applyEvent: (event) => { this.applyEvent(event) },
+    }
+  }
+
+  private buildMessageReadDeps(): MessageRead.MessageReadDeps {
+    return {
+      storage: this.storage,
+      transcriptsDir: this.transcriptsDir,
+      cachedTranscriptRef: this.cachedTranscriptRef,
+      legacyMessagesByChatId: this.legacyMessagesByChatId,
+      seenMessageIdsByChatId: this.seenMessageIdsByChatId,
+      queuedMessagesByChatId: this.state.queuedMessagesByChatId,
+      chatsById: this.state.chatsById,
+      listPendingToolRequests: (chatId) => this.listPendingToolRequests(chatId),
     }
-    return entries
   }
 
-  private getSeenMessageIds(chatId: string): Set<string> {
-    let set = this.seenMessageIdsByChatId.get(chatId)
-    if (!set) {
-      set = new Set<string>()
-      this.seenMessageIdsByChatId.set(chatId, set)
+  private buildPeripheralEventsDeps(): PeripheralEvents.PeripheralEventsDeps {
+    return {
+      storage: this.storage,
+      tunnelLogPath: this.tunnelLogPath,
+      sharesLogPath: this.sharesLogPath,
+      pushLogPath: this.pushLogPath,
+      tunnelEventsByChatId: this.tunnelEventsByChatId,
+      shareEventsAll: this.shareEventsAll,
+      getWriteChain: () => this.writeChain,
+      setWriteChain: (p) => { this.writeChain = p },
     }
-    return set
   }
 
-  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,
+  private buildEntityWriteDeps(): EntityWrite.EntityWriteDeps {
+    return {
+      storage: this.storage,
+      dataDir: this.dataDir,
+      sidebarProjectOrderPath: this.sidebarProjectOrderPath,
+      projectsLogPath: this.projectsLogPath,
+      chatsLogPath: this.chatsLogPath,
+      queuedMessagesLogPath: this.queuedMessagesLogPath,
+      stacksLogPath: this.stacksLogPath,
+      projectsById: this.state.projectsById,
+      projectIdsByPath: this.state.projectIdsByPath,
+      chatsById: this.state.chatsById,
+      queuedMessagesByChatId: this.state.queuedMessagesByChatId,
+      stacksById: this.state.stacksById,
+      sidebarProjectOrderRef: this.sidebarProjectOrderRef,
+      getWriteChain: () => this.writeChain,
+      setWriteChain: (p) => { this.writeChain = p },
+      append: (filePath, event) => this.append(filePath, event),
+    }
+  }
+
+  private buildSessionWriteDeps(): EntityWrite.SessionWriteDeps {
+    return {
+      chatsById: this.state.chatsById,
+      turnsLogPath: this.turnsLogPath,
+      schedulesLogPath: this.schedulesLogPath,
+      append: (filePath, event) => this.append(filePath, event),
     }
-    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,
+  private buildChatTranscriptWriteDeps(): TranscriptWrite.ChatTranscriptWriteDeps {
+    return {
+      storage: this.storage,
+      transcriptsDir: this.transcriptsDir,
+      dataDir: this.dataDir,
+      cachedTranscriptRef: this.cachedTranscriptRef,
+      seenMessageIdsByChatId: this.seenMessageIdsByChatId,
+      chatsById: this.state.chatsById,
+      toolRequestsById: this.state.toolRequestsById,
+      chatsLogPath: this.chatsLogPath,
+      turnsLogPath: this.turnsLogPath,
+      getWriteChain: () => this.writeChain,
+      setWriteChain: (p) => { this.writeChain = p },
+      append: (filePath, event) => this.append(filePath, event),
+      getMessages: (chatId) => this.getMessages(chatId),
+      getSeenMessageIds: (chatId) => this.getSeenMessageIds(chatId),
+      listPendingToolRequests: (chatId) => this.listPendingToolRequests(chatId),
+    }
+  }
+
+  private buildOrchSubscriptionDeps(): OrchSubscription.OrchSubscriptionDeps {
+    return {
+      orchRunsById: this.state.orchRunsById,
+      orchLogPath: this.orchLogPath,
+      orchRunsSubscribers: this.orchSubscriptionState.orchRunsSubscribers,
+      applyEvent: (e) => { this.applyEvent(e) },
+      enqueueDiskAppend: (fp, p) => { this.enqueueDiskAppend(fp, p) },
     }
-    await this.append(this.projectsLogPath, event)
   }
 
-  async setProjectStar(projectId: string, starred: boolean) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    const now = Date.now()
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_star_set",
-      timestamp: now,
-      projectId,
-      starredAt: starred ? now : null,
+  private buildToolRequestWriteDeps(): ToolRequestWriteDeps {
+    return {
+      toolRequestsById: this.state.toolRequestsById,
+      toolRequestsLogPath: this.toolRequestsLogPath,
+      append: (fp, e) => this.append(fp, e),
     }
-    await this.append(this.projectsLogPath, event)
   }
 
-  async createStack(title: string, projectIds: string[]): Promise<StackRecord> {
-    const trimmed = title.trim()
-    if (trimmed === "") throw new Error("Stack title cannot be empty")
-    if (projectIds.length < 2) throw new Error("Stack requires at least 2 projects")
-    if (new Set(projectIds).size !== projectIds.length) throw new Error("Stack projectIds contain duplicates")
-    for (const projectId of projectIds) {
-      const project = this.state.projectsById.get(projectId)
-      if (!project || project.deletedAt) throw new Error(`Project not found: ${projectId}`)
-    }
-    const stackId = crypto.randomUUID()
-    const event: StackEvent = {
-      v: STORE_VERSION,
-      type: "stack_added",
-      timestamp: Date.now(),
-      stackId,
-      title: trimmed,
-      projectIds: [...projectIds],
+  private buildAppendSubagentDeps(): AppendSubagentDeps {
+    return {
+      chatsById: this.state.chatsById,
+      turnsLogPath: this.turnsLogPath,
+      dataDir: this.dataDir,
+      applyEvent: (e) => { this.applyEvent(e) },
+      enqueueDiskAppend: (fp, p) => { this.enqueueDiskAppend(fp, p) },
     }
-    await this.append(this.stacksLogPath, event)
-    return this.state.stacksById.get(stackId)!
   }
 
-  getStack(stackId: string): StackRecord | null {
-    const stack = this.state.stacksById.get(stackId)
-    return stack && !stack.deletedAt ? stack : null
-  }
+  // ─── Private helpers ─────────────────────────────────────────────────────
 
-  listStacks(): StackRecord[] {
-    return [...this.state.stacksById.values()].filter((s) => !s.deletedAt)
-  }
+  private getSeenMessageIds(chatId: string): Set<string> { return MessageRead.getSeenMessageIds(this.buildMessageReadDeps(), chatId) }
 
-  async renameStack(stackId: string, title: string): Promise<void> {
-    const stack = this.state.stacksById.get(stackId)
-    if (!stack || stack.deletedAt) throw new Error("Stack not found")
-    const trimmed = title.trim()
-    if (trimmed === "") throw new Error("Stack title cannot be empty")
-    if (trimmed === stack.title) return
-    const event: StackEvent = {
-      v: STORE_VERSION,
-      type: "stack_renamed",
-      timestamp: Date.now(),
-      stackId,
-      title: trimmed,
-    }
-    await this.append(this.stacksLogPath, event)
-  }
+  async openProject(localPath: string, title?: string) { return EntityWrite.openProject(this.buildEntityWriteDeps(), localPath, title) }
 
-  async removeStack(stackId: string): Promise<void> {
-    const stack = this.state.stacksById.get(stackId)
-    if (!stack) throw new Error("Stack not found")
-    if (stack.deletedAt) return
-    const event: StackEvent = {
-      v: STORE_VERSION,
-      type: "stack_removed",
-      timestamp: Date.now(),
-      stackId,
-    }
-    await this.append(this.stacksLogPath, event)
-  }
+  async removeProject(projectId: string) { return EntityWrite.removeProject(this.buildEntityWriteDeps(), projectId) }
 
-  async addProjectToStack(stackId: string, projectId: string): Promise<void> {
-    const stack = this.state.stacksById.get(stackId)
-    if (!stack || stack.deletedAt) throw new Error("Stack not found")
-    const project = this.state.projectsById.get(projectId)
-    if (!project || project.deletedAt) throw new Error("Project not found")
-    if (stack.projectIds.includes(projectId)) return
-    const event: StackEvent = {
-      v: STORE_VERSION,
-      type: "stack_project_added",
-      timestamp: Date.now(),
-      stackId,
-      projectId,
-    }
-    await this.append(this.stacksLogPath, event)
-  }
+  async setProjectStar(projectId: string, starred: boolean) { return EntityWrite.setProjectStar(this.buildEntityWriteDeps(), projectId, starred) }
 
-  async removeProjectFromStack(stackId: string, projectId: string): Promise<void> {
+  async createStack(title: string, projectIds: string[]): Promise<StackRecord> { return EntityWrite.createStack(this.buildEntityWriteDeps(), title, projectIds) }
+
+  getStack(stackId: string): StackRecord | null {
     const stack = this.state.stacksById.get(stackId)
-    if (!stack || stack.deletedAt) throw new Error("Stack not found")
-    if (!stack.projectIds.includes(projectId)) return
-    if (stack.projectIds.length <= 2) {
-      throw new Error("Stack must keep at least 2 projects. Delete the stack instead.")
-    }
-    const event: StackEvent = {
-      v: STORE_VERSION,
-      type: "stack_project_removed",
-      timestamp: Date.now(),
-      stackId,
-      projectId,
-    }
-    await this.append(this.stacksLogPath, event)
+    return stack && !stack.deletedAt ? stack : null
   }
 
-  async setSidebarProjectOrder(projectIds: string[]) {
-    const validProjectIds = projectIds.filter((projectId) => {
-      const project = this.state.projectsById.get(projectId)
-      return Boolean(project && !project.deletedAt)
-    })
+  listStacks(): StackRecord[] { return [...this.state.stacksById.values()].filter((s) => !s.deletedAt) }
 
-    const uniqueProjectIds = [...new Set(validProjectIds)]
-    const current = this.sidebarProjectOrder
-    if (
-      uniqueProjectIds.length === current.length
-      && uniqueProjectIds.every((projectId, index) => current[index] === projectId)
-    ) {
-      return
-    }
+  async renameStack(stackId: string, title: string): Promise<void> { return EntityWrite.renameStack(this.buildEntityWriteDeps(), stackId, title) }
 
-    this.writeChain = this.writeChain.then(async () => {
-      await this.writeSidebarProjectOrderFile(uniqueProjectIds)
-      this.sidebarProjectOrder = [...uniqueProjectIds]
-    })
-    return this.writeChain
-  }
+  async removeStack(stackId: string): Promise<void> { return EntityWrite.removeStack(this.buildEntityWriteDeps(), stackId) }
+
+  async addProjectToStack(stackId: string, projectId: string): Promise<void> { return EntityWrite.addProjectToStack(this.buildEntityWriteDeps(), stackId, projectId) }
+
+  async removeProjectFromStack(stackId: string, projectId: string): Promise<void> { return EntityWrite.removeProjectFromStack(this.buildEntityWriteDeps(), stackId, projectId) }
+
+  async setSidebarProjectOrder(projectIds: string[]) { return EntityWrite.setSidebarProjectOrder(this.buildEntityWriteDeps(), projectIds) }
 
   async createChat(
     projectId: string,
     options?: { stackId?: string; stackBindings?: StackBinding[] },
   ): Promise<import("./events").ChatRecord> {
-    const project = this.state.projectsById.get(projectId)
-    if (!project || project.deletedAt) {
-      throw new Error("Project not found")
-    }
-
-    if (options?.stackId !== undefined || options?.stackBindings !== undefined) {
-      if (options.stackId === undefined || options.stackBindings === undefined) {
-        throw new Error("stackId and stackBindings must be provided together")
-      }
-      const stack = this.state.stacksById.get(options.stackId)
-      if (!stack || stack.deletedAt) throw new Error("Stack not found")
-      if (options.stackBindings.length === 0) throw new Error("stackBindings cannot be empty")
-      const primaries = options.stackBindings.filter((b) => b.role === "primary")
-      if (primaries.length !== 1) throw new Error("Exactly one primary binding required")
-      const seenProjects = new Set<string>()
-      for (const binding of options.stackBindings) {
-        if (seenProjects.has(binding.projectId)) {
-          throw new Error("Duplicate projectId in stackBindings")
-        }
-        seenProjects.add(binding.projectId)
-        if (!stack.projectIds.includes(binding.projectId)) {
-          throw new Error(`Binding projectId not a member of stack: ${binding.projectId}`)
-        }
-        const peerProject = this.state.projectsById.get(binding.projectId)
-        if (!peerProject || peerProject.deletedAt) {
-          throw new Error(`Project not found: ${binding.projectId}`)
-        }
-        if (typeof binding.worktreePath !== "string" || binding.worktreePath.trim() === "") {
-          throw new Error("worktreePath must be a non-empty string")
-        }
-      }
-      if (primaries[0].projectId !== projectId) {
-        throw new Error("Primary binding projectId must match createChat projectId")
-      }
-    }
-
-    const chatId = crypto.randomUUID()
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_created",
-      timestamp: Date.now(),
-      chatId,
-      projectId,
-      title: "New Chat",
-      ...(options?.stackId !== undefined ? { stackId: options.stackId } : {}),
-      ...(options?.stackBindings !== undefined ? { stackBindings: options.stackBindings.map((b) => ({ ...b })) } : {}),
-    }
-    await this.append(this.chatsLogPath, event)
-    return this.state.chatsById.get(chatId)!
-  }
-
-  async forkChat(sourceChatId: string) {
-    const sourceChat = this.requireChat(sourceChatId)
-    const sourceProvider = sourceChat.provider
-    if (!sourceProvider) {
-      throw new Error("Chat cannot be forked")
-    }
-    const sourceSessionToken =
-      sourceChat.sessionTokensByProvider[sourceProvider]
-      ?? (sourceChat.pendingForkSessionToken?.provider === sourceProvider
-        ? sourceChat.pendingForkSessionToken.token
-        : null)
-    if (!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),
-      ...(sourceChat.stackId !== undefined ? { stackId: sourceChat.stackId } : {}),
-      ...(sourceChat.stackBindings !== undefined
-        ? { stackBindings: sourceChat.stackBindings.map((b) => ({ ...b })) }
-        : {}),
-    }
-    await this.append(this.chatsLogPath, createEvent)
-    await this.setChatProvider(chatId, sourceProvider)
-    await this.setPlanMode(chatId, sourceChat.planMode)
-    await this.setPendingForkSessionToken(chatId, { provider: sourceProvider, token: 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 this.storage.mkdir(this.transcriptsDir)
-        await this.storage.writeText(transcriptPath, `${payload}\n`)
-        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)!
+    return EntityWrite.createChat(this.buildEntityWriteDeps(), projectId, options)
   }
 
-  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 forkChat(sourceChatId: string) { return TranscriptWrite.forkChat(this.buildChatTranscriptWriteDeps(), sourceChatId) }
 
-  async deleteChat(chatId: string) {
-    const chat = this.requireChat(chatId)
-    const projectId = chat.projectId
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_deleted",
-      timestamp: Date.now(),
-      chatId,
-    }
-    await this.append(this.chatsLogPath, event)
-    for (const [id, req] of this.state.toolRequestsById) {
-      if (req.chatId === chatId) {
-        this.state.toolRequestsById.delete(id)
-      }
-    }
-    await this.removeSubagentResultsDir(projectId, chatId)
-  }
+  async renameChat(chatId: string, title: string) { return EntityWrite.renameChat(this.buildEntityWriteDeps(), chatId, title) }
 
-  private async removeSubagentResultsDir(projectId: string, chatId: string) {
-    const dir = path.join(
-      this.dataDir, "projects", projectId, "chats", chatId, "subagent-results",
-    )
-    try {
-      await this.storage.remove(dir, { recursive: true })
-    } catch (err) {
-      log.warn(`${LOG_PREFIX} subagent-results cleanup failed`, { chatId, err })
-    }
-  }
+  async deleteChat(chatId: string) { return TranscriptWrite.deleteChat(this.buildChatTranscriptWriteDeps(), chatId) }
 
-  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 archiveChat(chatId: string) { return TranscriptWrite.archiveChat(this.buildChatTranscriptWriteDeps(), chatId) }
 
-  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 unarchiveChat(chatId: string) { return TranscriptWrite.unarchiveChat(this.buildChatTranscriptWriteDeps(), chatId) }
 
   async pruneStaleEmptyChats(args?: {
     now?: number
@@ -1503,352 +332,48 @@ export class EventStore implements PushEventStore {
     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 this.storage.remove(transcriptPath)
-      if (this.cachedTranscript?.chatId === chat.id) {
-        this.cachedTranscript = null
-      }
-      await this.removeSubagentResultsDir(chat.projectId, chat.id)
-
-      prunedChatIds.push(chat.id)
-    }
-
-    return prunedChatIds
+    return TranscriptWrite.pruneStaleEmptyChats(this.buildChatTranscriptWriteDeps(), args)
   }
 
-  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 setChatProvider(chatId: string, provider: AgentProvider) { return EntityWrite.setChatProvider(this.buildEntityWriteDeps(), chatId, provider) }
 
-  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 setPlanMode(chatId: string, planMode: boolean) { return EntityWrite.setPlanMode(this.buildEntityWriteDeps(), chatId, planMode) }
 
-  async setCompactFailureCount(chatId: string, compactFailureCount: number) {
-    const chat = this.requireChat(chatId)
-    if ((chat.compactFailureCount ?? 0) === compactFailureCount) return
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_compact_failures_set",
-      timestamp: Date.now(),
-      chatId,
-      compactFailureCount,
-    }
-    await this.append(this.chatsLogPath, event)
-  }
+  async setCompactFailureCount(chatId: string, compactFailureCount: number) { return EntityWrite.setCompactFailureCount(this.buildEntityWriteDeps(), chatId, compactFailureCount) }
 
-  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 setChatReadState(chatId: string, unread: boolean) { return EntityWrite.setChatReadState(this.buildEntityWriteDeps(), chatId, unread) }
 
-  async setChatPolicyOverride(chatId: string, policyOverride: ChatPermissionPolicyOverride | null) {
-    this.requireChat(chatId)
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_policy_override_set",
-      timestamp: Date.now(),
-      chatId,
-      policyOverride,
-    }
-    await this.append(this.chatsLogPath, event)
-  }
+  async setChatPolicyOverride(chatId: string, policyOverride: ChatPermissionPolicyOverride | null) { return EntityWrite.setChatPolicyOverride(this.buildEntityWriteDeps(), chatId, policyOverride) }
 
-  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))
-      // Dedupe by messageId: if a transcript entry from the same JSONL source
-      // message has already been appended, skip. Server-generated entries
-      // without messageId (e.g. interrupted, context_cleared) always append.
-      const mid = entry.messageId
-      if (typeof mid === "string" && mid.length > 0) {
-        // Ensure the transcript is loaded so the seen set is populated.
-        this.getMessages(chatId)
-        const seen = this.getSeenMessageIds(chatId)
-        if (seen.has(mid)) {
-          logSendToStartingProfile("event_store.append_message_dedup", {
-            chatId,
-            messageId: mid,
-            kind: entry.kind,
-          })
-          return
-        }
-        seen.add(mid)
-      }
-      await this.storage.mkdir(this.transcriptsDir)
-      const beforeAppendAt = performance.now()
-      await this.storage.appendText(transcriptPath, payload)
-      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 appendMessage(chatId: string, entry: TranscriptEntry) { return TranscriptWrite.appendMessage(this.buildChatTranscriptWriteDeps(), chatId, entry) }
 
-  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 enqueueMessage(chatId: string, message: Omit<QueuedChatMessage, "id" | "createdAt"> & Partial<Pick<QueuedChatMessage, "id" | "createdAt">>) { return EntityWrite.enqueueMessage(this.buildEntityWriteDeps(), chatId, message) }
 
-  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 removeQueuedMessage(chatId: string, queuedMessageId: string) { return EntityWrite.removeQueuedMessage(this.buildEntityWriteDeps(), chatId, queuedMessageId) }
 
-  async recordTurnStarted(chatId: string, runConfig?: TurnRunConfig) {
-    this.requireChat(chatId)
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "turn_started",
-      timestamp: Date.now(),
-      chatId,
-      ...(runConfig ? { runConfig } : {}),
-    }
-    await this.append(this.turnsLogPath, event)
-  }
+  async recordTurnStarted(chatId: string, runConfig?: TurnRunConfig) { return EntityWrite.recordTurnStarted(this.buildSessionWriteDeps(), chatId, runConfig) }
 
-  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 recordTurnFinished(chatId: string) { return EntityWrite.recordTurnFinished(this.buildSessionWriteDeps(), chatId) }
 
-  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 recordTurnFailed(chatId: string, error: string) { return EntityWrite.recordTurnFailed(this.buildSessionWriteDeps(), chatId, error) }
 
-  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 recordTurnCancelled(chatId: string) { return EntityWrite.recordTurnCancelled(this.buildSessionWriteDeps(), chatId) }
 
-  async appendSubagentEvent(event: SubagentRunEvent) {
-    let effectiveEvent = event
-    if (event.type === "subagent_entry_appended" && event.entry.kind === "tool_result") {
-      const chat = this.state.chatsById.get(event.chatId)
-      if (chat) {
-        effectiveEvent = {
-          ...event,
-          entry: await capTranscriptEntry({
-            entry: event.entry,
-            chatId: event.chatId,
-            runId: event.runId,
-            projectId: chat.projectId,
-            kannaRoot: this.dataDir,
-          }),
-        }
-      }
-    }
-    // Apply in-memory synchronously so the UI sees the update immediately,
-    // decoupled from disk I/O backlog on writeChain (scoped to ephemeral
-    // subagent_* events only — structural events keep strict append→apply ordering).
-    this.applyEvent(effectiveEvent)
-    this.enqueueDiskAppend(this.turnsLogPath, `${JSON.stringify(effectiveEvent)}\n`)
-  }
+  async appendSubagentEvent(event: SubagentRunEvent) { return appendSubagentEventFn(this.buildAppendSubagentDeps(), event) }
 
-  getSubagentRuns(chatId: string): Record<string, SubagentRunSnapshot> {
-    const map = this.state.subagentRunsByChatId.get(chatId)
-    if (!map) return {}
-    return Object.fromEntries(map.entries())
-  }
+  getSubagentRuns(chatId: string): Record<string, SubagentRunSnapshot> { return getSubagentRunsFromMap(this.state.subagentRunsByChatId, chatId) }
 
-  *runningSubagentRuns(): Iterable<SubagentRunSnapshot> {
-    for (const map of this.state.subagentRunsByChatId.values()) {
-      for (const run of map.values()) {
-        if (run.status === "running") yield run
-      }
-    }
-  }
+  *runningSubagentRuns(): Iterable<SubagentRunSnapshot> { yield* runningSubagentRunsFromMap(this.state.subagentRunsByChatId) }
 
-  async setSessionTokenForProvider(
-    chatId: string,
-    provider: AgentProvider,
-    sessionToken: string | null,
-  ) {
-    const chat = this.requireChat(chatId)
-    if ((chat.sessionTokensByProvider[provider] ?? null) === sessionToken) return
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "session_token_set",
-      timestamp: Date.now(),
-      chatId,
-      sessionToken,
-      provider,
-    }
-    await this.append(this.turnsLogPath, event)
-  }
+  async setSessionTokenForProvider(chatId: string, provider: AgentProvider, sessionToken: string | null) { return EntityWrite.setSessionTokenForProvider(this.buildSessionWriteDeps(), chatId, provider, sessionToken) }
 
-  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 recordSessionCommandsLoaded(chatId: string, commands: SlashCommand[]) { return EntityWrite.recordSessionCommandsLoaded(this.buildSessionWriteDeps(), chatId, commands) }
 
-  async setPendingForkSessionToken(
-    chatId: string,
-    value: { provider: AgentProvider; token: string } | null,
-  ) {
-    const chat = this.requireChat(chatId)
-    const current = chat.pendingForkSessionToken ?? null
-    const same =
-      (current == null && value == null)
-      || (current != null && value != null
-        && current.provider === value.provider
-        && current.token === value.token)
-    if (same) return
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "pending_fork_session_token_set",
-      timestamp: Date.now(),
-      chatId,
-      pendingForkSessionToken: value?.token ?? null,
-      provider: value?.provider,
-    }
-    await this.append(this.turnsLogPath, event)
+  async setPendingForkSessionToken(chatId: string, value: { provider: AgentProvider; token: string } | null) {
+    return EntityWrite.setPendingForkSessionToken(this.buildSessionWriteDeps(), chatId, value)
   }
 
-  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)
-  }
+  async setSourceHash(chatId: string, sourceHash: string | null) { return EntityWrite.setSourceHash(this.buildEntityWriteDeps(), chatId, sourceHash) }
 
   getProject(projectId: string) {
     const project = this.state.projectsById.get(projectId)
@@ -1870,110 +395,23 @@ export class EventStore implements PushEventStore {
     return chat
   }
 
-  getSidebarProjectOrder() {
-    return [...this.sidebarProjectOrder]
-  }
+  getSidebarProjectOrder() { return [...this.sidebarProjectOrderRef.value] }
 
-  private getMessagesPageFromEntries(entries: TranscriptEntry[], limit: number, beforeIndex?: number): TranscriptPageResult {
-    if (entries.length === 0) {
-      return { entries: [], hasOlder: false, olderCursor: null }
-    }
+  // ─── Message read methods (thin delegates) ────────────────────────────────
 
-    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) { return MessageRead.getMessages(this.buildMessageReadDeps(), chatId) }
 
-  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 }
-    }
+  getQueuedMessages(chatId: string) { return MessageRead.getQueuedMessages(this.buildMessageReadDeps(), chatId) }
 
-    const entries = coalesceContextWindowUpdates(this.getMessages(chatId))
-    const page = this.getMessagesPageFromEntries(entries, limit)
+  getQueuedMessage(chatId: string, queuedMessageId: string) { return MessageRead.getQueuedMessage(this.buildMessageReadDeps(), chatId, queuedMessageId) }
 
-    return {
-      messages: page.entries,
-      hasOlder: page.hasOlder,
-      olderCursor: page.olderCursor,
-    }
-  }
+  getRecentMessagesPage(chatId: string, limit: number): ChatHistoryPage { return MessageRead.getRecentMessagesPage(this.buildMessageReadDeps(), chatId, limit) }
 
-  getMessagesPageBefore(chatId: string, beforeCursor: string, limit: number): ChatHistoryPage {
-    if (limit <= 0) {
-      return { messages: [], hasOlder: false, olderCursor: null }
-    }
+  getMessagesPageBefore(chatId: string, beforeCursor: string, limit: number): ChatHistoryPage { return MessageRead.getMessagesPageBefore(this.buildMessageReadDeps(), chatId, beforeCursor, limit) }
 
-    const beforeIndex = decodeCursor(beforeCursor)
-    // Coalesce identically to getRecentMessagesPage so cursors (which index the
-    // coalesced array) stay consistent across recent + load-older paging.
-    const entries = coalesceContextWindowUpdates(this.getMessages(chatId))
-    const page = this.getMessagesPageFromEntries(entries, limit, beforeIndex)
+  getRecentChatHistory(chatId: string, recentLimit: number) { return MessageRead.getRecentChatHistory(this.buildMessageReadDeps(), chatId, recentLimit) }
 
-    return {
-      messages: page.entries,
-      hasOlder: page.hasOlder,
-      olderCursor: page.olderCursor,
-    }
-  }
-
-  getRecentChatHistory(chatId: string, recentLimit: number) {
-    const page = this.getRecentMessagesPage(chatId, recentLimit)
-    const pending = this.listPendingToolRequests(chatId)
-    const pendingEntries: TranscriptEntry[] = pending.map((req) => ({
-      _id: `pending-tool-request-${req.id}`,
-      createdAt: req.createdAt,
-      kind: "pending_tool_request",
-      toolRequestId: req.id,
-      toolName: req.toolName,
-      arguments: req.arguments,
-    }))
-    const merged = [...page.messages, ...pendingEntries]
-    return {
-      messages: merged,
-      history: getHistorySnapshot({
-        entries: merged,
-        hasOlder: page.hasOlder,
-        olderCursor: page.olderCursor,
-      }, recentLimit),
-    }
-  }
-
-  listProjects() {
-    return [...this.state.projectsById.values()].filter((project) => !project.deletedAt)
-  }
+  listProjects() { return [...this.state.projectsById.values()].filter((project) => !project.deletedAt) }
 
   listChatsByProject(projectId: string) {
     return [...this.state.chatsById.values()]
@@ -1981,556 +419,85 @@ export class EventStore implements PushEventStore {
       .sort((a, b) => (b.lastMessageAt ?? b.updatedAt) - (a.lastMessageAt ?? a.updatedAt))
   }
 
-  getChatCount(projectId: string) {
-    return this.listChatsByProject(projectId).length
-  }
+  getChatCount(projectId: string) { return MessageRead.getChatCount(this.buildMessageReadDeps(), projectId) }
 
-  async getLegacyTranscriptStats(): Promise<LegacyTranscriptStats> {
-    const messagesLogSize = await this.storage.size(this.messagesLogPath)
-    const sources: LegacyTranscriptStats["sources"] = []
-    if (this.snapshotHasLegacyMessages) {
-      sources.push("snapshot")
-    }
-    if (messagesLogSize > 0) {
-      sources.push("messages_log")
-    }
+  async getLegacyTranscriptStats(): Promise<LegacyTranscriptStats> { return getLegacyTranscriptStatsFn(this.buildInitDeps()) }
 
-    let entryCount = 0
-    for (const entries of this.legacyMessagesByChatId.values()) {
-      entryCount += entries.length
-    }
+  async hasLegacyTranscriptData() { return hasLegacyTranscriptDataFn(this.buildInitDeps()) }
 
-    return {
-      hasLegacyData: sources.length > 0 || this.legacyMessagesByChatId.size > 0,
-      sources,
-      chatCount: this.legacyMessagesByChatId.size,
-      entryCount,
-    }
-  }
+  async snapshotAndTruncateLogs() { return snapshotAndTruncateLogsFn(this.buildInitDeps()) }
 
-  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],
-      })),
-      stacks: [...this.state.stacksById.values()]
-        .filter((stack) => !stack.deletedAt)
-        .map((stack) => ({ ...stack, projectIds: [...stack.projectIds] })),
-    }
-  }
+  async migrateLegacyTranscripts(onProgress?: (message: string) => void) { return migrateLegacyTranscriptsFn(this.buildInitDeps(), onProgress) }
 
-  async snapshotAndTruncateLogs() {
-    const snapshot = this.createSnapshot()
-    await this.storage.writeText(this.snapshotPath, JSON.stringify(snapshot, null, 2))
-    await Promise.all([
-      this.storage.writeText(this.projectsLogPath, ""),
-      this.storage.writeText(this.chatsLogPath, ""),
-      this.storage.writeText(this.messagesLogPath, ""),
-      this.storage.writeText(this.queuedMessagesLogPath, ""),
-      this.storage.writeText(this.turnsLogPath, ""),
-      this.storage.writeText(this.schedulesLogPath, ""),
-      this.storage.writeText(this.stacksLogPath, ""),
-      // tunnels.jsonl is NOT compacted into the snapshot — it's left as-is
-      // so that active tunnel state survives server restarts.
-      // tool-requests.jsonl is NOT persisted to the snapshot. After compaction,
-      // in-memory state remains intact for the current process lifetime.
-      // On next server boot, tool-requests will be absent (fail-closed);
-      // Task 7 recoverOnStartup marks them session_closed.
-      this.storage.writeText(this.toolRequestsLogPath, ""),
-    ])
-  }
-
-  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 this.storage.mkdir(this.transcriptsDir)
-    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 this.storage.writeText(tempPath, payload ? `${payload}\n` : "")
-      await this.storage.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.snapshotAndTruncateLogs()
-    this.cachedTranscript = null
-    onProgress?.(`${LOG_PREFIX} transcript migration complete`)
-    return true
-  }
-
-  private async shouldSnapshotLogs() {
-    const sizes = await Promise.all([
-      this.storage.size(this.projectsLogPath),
-      this.storage.size(this.chatsLogPath),
-      this.storage.size(this.messagesLogPath),
-      this.storage.size(this.queuedMessagesLogPath),
-      this.storage.size(this.turnsLogPath),
-      this.storage.size(this.schedulesLogPath),
-      this.storage.size(this.stacksLogPath),
-      this.storage.size(this.toolRequestsLogPath),
-    ])
-    return sizes.reduce((total, size) => total + size, 0) >= SNAPSHOT_THRESHOLD_BYTES
-  }
-
-  async appendAutoContinueEvent(event: AutoContinueEvent) {
-    return this.append(this.schedulesLogPath, event)
-  }
+  async appendAutoContinueEvent(event: AutoContinueEvent) { return EntityWrite.appendAutoContinueEvent(this.buildSessionWriteDeps(), event) }
 
   getAutoContinueEvents(chatId: string): AutoContinueEvent[] {
     const list = this.state.autoContinueEventsByChatId.get(chatId)
     return list ? [...list] : []
   }
 
-  listAutoContinueChats(): string[] {
-    return [...this.state.autoContinueEventsByChatId.keys()]
-  }
+  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 this.storage.appendText(this.tunnelLogPath, payload)
-      this.applyTunnelEvent(event)
-    })
-    await this.writeChain
-  }
+  // ─── Peripheral event methods (thin delegates) ───────────────────────────
 
-  getTunnelEvents(chatId: string): CloudflareTunnelEvent[] {
-    const list = this.tunnelEventsByChatId.get(chatId)
-    return list ? [...list] : []
-  }
+  async appendTunnelEvent(event: CloudflareTunnelEvent): Promise<void> { return PeripheralEvents.appendTunnelEvent(this.buildPeripheralEventsDeps(), event) }
 
-  listTunnelChats(): string[] {
-    return [...this.tunnelEventsByChatId.keys()]
-  }
+  getTunnelEvents(chatId: string): CloudflareTunnelEvent[] { return PeripheralEvents.getTunnelEvents(this.buildPeripheralEventsDeps(), chatId) }
 
-  private applyTunnelEvent(event: CloudflareTunnelEvent): void {
-    const existing = this.tunnelEventsByChatId.get(event.chatId) ?? []
-    existing.push(event)
-    this.tunnelEventsByChatId.set(event.chatId, existing)
-  }
+  listTunnelChats(): string[] { return PeripheralEvents.listTunnelChats(this.buildPeripheralEventsDeps()) }
 
-  private async loadTunnelEvents(): Promise<void> {
-    if (!(await this.storage.exists(this.tunnelLogPath))) return
-    const text = await this.storage.readText(this.tunnelLogPath)
-    if (!text.trim()) return
-
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim()
-      if (!line) continue
-      try {
-        const event: CloudflareTunnelEvent = JSON.parse(line)
-        this.applyTunnelEvent(event)
-      } catch {
-        log.warn(`${LOG_PREFIX} Ignoring malformed line in tunnels.jsonl`)
-      }
-    }
-  }
+  private async loadTunnelEvents(): Promise<void> { await PeripheralEvents.loadTunnelEvents(this.buildPeripheralEventsDeps()) }
 
-  async appendShareEvent(event: ShareEvent): Promise<void> {
-    const payload = `${JSON.stringify(event)}\n`
-    this.writeChain = this.writeChain.then(async () => {
-      await this.storage.appendText(this.sharesLogPath, payload)
-      this.shareEventsAll.push(event)
-    })
-    await this.writeChain
-  }
+  async appendShareEvent(event: ShareEvent): Promise<void> { return PeripheralEvents.appendShareEvent(this.buildPeripheralEventsDeps(), event) }
 
-  getShareEvents(): ShareEvent[] {
-    return [...this.shareEventsAll]
-  }
+  getShareEvents(): ShareEvent[] { return PeripheralEvents.getShareEvents(this.buildPeripheralEventsDeps()) }
 
-  private async loadShareEvents(): Promise<void> {
-    if (!(await this.storage.exists(this.sharesLogPath))) return
-    const text = await this.storage.readText(this.sharesLogPath)
-    if (!text.trim()) return
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim()
-      if (!line) continue
-      try {
-        const event: ShareEvent = JSON.parse(line)
-        this.shareEventsAll.push(event)
-      } catch {
-        log.warn(`${LOG_PREFIX} Ignoring malformed line in shares.jsonl`)
-      }
-    }
-  }
+  private async loadShareEvents(): Promise<void> { await PeripheralEvents.loadShareEvents(this.buildPeripheralEventsDeps()) }
 
-  async appendPushEvent(event: PushEvent): Promise<void> {
-    const payload = `${JSON.stringify(event)}\n`
-    this.writeChain = this.writeChain.then(async () => {
-      await this.storage.appendText(this.pushLogPath, payload)
-    })
-    await this.writeChain
-  }
+  async appendPushEvent(event: PushEvent): Promise<void> { return PeripheralEvents.appendPushEvent(this.buildPeripheralEventsDeps(), event) }
 
-  async loadPushEvents(): Promise<PushEvent[]> {
-    if (!(await this.storage.exists(this.pushLogPath))) return []
-    const text = await this.storage.readText(this.pushLogPath)
-    if (!text.trim()) return []
-
-    const events: PushEvent[] = []
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim()
-      if (!line) continue
-      try {
-        const pushEvent: PushEvent = JSON.parse(line)
-        events.push(pushEvent)
-      } catch {
-        log.warn(`${LOG_PREFIX} Ignoring malformed line in push.jsonl`)
-      }
-    }
-    return events
-  }
+  async loadPushEvents(): Promise<PushEvent[]> { return PeripheralEvents.loadPushEvents(this.buildPeripheralEventsDeps()) }
 
-  async putToolRequest(req: ToolRequest): Promise<void> {
-    this.state.toolRequestsById.set(req.id, { ...req })
-    await this.append(this.toolRequestsLogPath, {
-      v: 3,
-      type: "tool_request_put",
-      timestamp: Date.now(),
-      request: req,
-    } satisfies ToolRequestEvent)
-  }
+  async putToolRequest(req: ToolRequest): Promise<void> { return putToolRequestFn(this.buildToolRequestWriteDeps(), req) }
 
-  getToolRequest(id: string): ToolRequest | null {
-    const req = this.state.toolRequestsById.get(id)
-    return req ? { ...req } : null
-  }
+  getToolRequest(id: string): ToolRequest | null { return getToolRequestFromMap(this.state.toolRequestsById, id) }
 
-  listPendingToolRequests(chatId: string): ToolRequest[] {
-    const out: ToolRequest[] = []
-    for (const req of this.state.toolRequestsById.values()) {
-      if (req.chatId !== chatId) continue
-      if (req.status !== "pending") continue
-      out.push({ ...req })
-    }
-    return out
-  }
+  listPendingToolRequests(chatId: string): ToolRequest[] { return listPendingToolRequestsFromMap(this.state.toolRequestsById, chatId) }
 
   async resolveToolRequest(
     id: string,
-    args: {
-      status: ToolRequestStatus
-      decision?: ToolRequestDecision
-      resolvedAt: number
-      mismatchReason?: string
-    },
+    args: { status: ToolRequestStatus; decision?: ToolRequestDecision; resolvedAt: number; mismatchReason?: string },
   ): Promise<void> {
-    const existing = this.state.toolRequestsById.get(id)
-    if (!existing) throw new Error(`resolveToolRequest: unknown id ${id}`)
-    const next: ToolRequest = {
-      ...existing,
-      status: args.status,
-      decision: args.decision ?? existing.decision,
-      resolvedAt: args.resolvedAt,
-      mismatchReason: args.mismatchReason,
-    }
-    this.state.toolRequestsById.set(id, next)
-    await this.append(this.toolRequestsLogPath, {
-      v: 3,
-      type: "tool_request_resolved",
-      timestamp: Date.now(),
-      id,
-      status: args.status,
-      decision: args.decision,
-      resolvedAt: args.resolvedAt,
-      mismatchReason: args.mismatchReason,
-    } satisfies ToolRequestEvent)
-  }
-
-  scanAllToolRequests(): ToolRequest[] {
-    return [...this.state.toolRequestsById.values()].map((req) => ({ ...req }))
+    return resolveToolRequestFn(this.buildToolRequestWriteDeps(), id, args)
   }
 
-  async flush(): Promise<void> {
-    await this.writeChain
-  }
-
-  private readonly orchRunsSubscribers = new Set<() => void>()
-
-  private applyOrchestrationEvent(event: OrchestrationEvent) {
-    if (event.type === "orch_run_created") {
-      const tasksById = new Map<string, OrchTaskRecord>()
-      for (const spec of event.tasks) {
-        tasksById.set(spec.id, {
-          taskId: spec.id,
-          title: spec.title,
-          prompt: spec.prompt,
-          scopePaths: spec.scopePaths ?? [],
-          state: "queued",
-          ownerWorkerId: null,
-          worktreePath: null,
-          branch: null,
-          baseSha: null,
-          phaseIndex: -1,
-          attempts: 0,
-          error: null,
-          commitSha: null,
-          lastPhaseOutput: null,
-          verifying: false,
-          updatedAt: event.timestamp,
-        })
-      }
-      this.state.orchRunsById.set(event.runId, {
-        runId: event.runId,
-        status: "running",
-        config: event.config,
-        tasksById,
-        taskOrder: event.tasks.map((t) => t.id),
-        worktrees: [],
-        eventLog: [event],
-        createdAt: event.timestamp,
-        updatedAt: event.timestamp,
-      })
-      return
-    }
-    const run = this.state.orchRunsById.get(event.runId)
-    if (!run) return
-    run.eventLog.push(event)
-    run.updatedAt = event.timestamp
-    if (event.type === "orch_run_completed" || event.type === "orch_run_cancelled") {
-      const trans = nextRunStatus(run.status, event.type)
-      if (!trans.ok) {
-        log.warn(`${LOG_PREFIX} dropped illegal orch run transition`, { runId: event.runId, from: run.status, event: event.type })
-        return
-      }
-      run.status = trans.next
-      return
-    }
-    if (event.type === "orch_scope_overlap_flagged") return // observability-only, no state fold
-    if (event.type === "orch_config_warning") return // observability-only, no state fold
-    // Worktree pool fold (F13)
-    if (event.type === "orch_worktree_provisioned") {
-      run.worktrees.push({
-        index: event.index, path: event.path, branch: event.branch,
-        heldByTaskId: null, initialized: false,
-      })
-      return
-    }
-    if (event.type === "orch_worktree_init_started") return // timeline-only
-    if (event.type === "orch_worktree_init_completed") {
-      const slot = run.worktrees.find((w) => w.index === event.index)
-      if (slot) slot.initialized = event.ok
-      return
-    }
-    const task = run.tasksById.get(event.taskId)
-    if (!task) return
-    // FSM guard: drop an illegal task transition rather than corrupt the read
-    // model. The engine only emits legal transitions, so this is a defensive
-    // invariant (also protects replay of an older/foreign log).
-    if (isTaskEventType(event.type)) {
-      const trans = nextTaskState(task.state, event.type)
-      if (!trans.ok) {
-        log.warn(`${LOG_PREFIX} dropped illegal orch task transition`, { runId: event.runId, taskId: event.taskId, from: task.state, event: event.type })
-        return
-      }
-    }
-    task.updatedAt = event.timestamp
-    const slotOf = (t: OrchTaskRecord) => run.worktrees.find((w) => w.path === t.worktreePath)
-    switch (event.type) {
-      case "orch_task_claimed":
-        task.state = "claimed"
-        task.ownerWorkerId = event.workerId
-        task.worktreePath = event.worktreePath
-        task.branch = event.branch
-        task.baseSha = event.baseSha
-        task.attempts += 1
-        {
-          const slot = slotOf(task)
-          if (slot) slot.heldByTaskId = task.taskId
-        }
-        break
-      case "orch_phase_started":
-        task.state = "running"
-        task.phaseIndex = event.phaseIndex
-        task.verifying = false
-        break
-      case "orch_phase_completed":
-        task.lastPhaseOutput = event.output
-        break
-      case "orch_gate_opened":
-        task.state = "gated"
-        break
-      case "orch_gate_resolved":
-        if (event.decision === "approve") task.state = "running"
-        // reject: state stays gated; the engine appends orch_task_failed next
-        break
-      case "orch_verify_started":
-        task.verifying = true // observable stage; task stays "running"
-        break
-      case "orch_verify_completed":
-        task.verifying = false
-        break
-      case "orch_task_committed":
-        task.state = "committed"
-        task.ownerWorkerId = null
-        task.commitSha = event.commitSha
-        task.verifying = false
-        {
-          const slot = slotOf(task)
-          if (slot?.heldByTaskId === task.taskId) slot.heldByTaskId = null
-        }
-        break
-      case "orch_task_failed":
-        task.state = "failed"
-        task.ownerWorkerId = null
-        task.error = event.error
-        task.verifying = false
-        {
-          const slot = slotOf(task)
-          if (slot?.heldByTaskId === task.taskId) slot.heldByTaskId = null
-        }
-        break
-      case "orch_task_requeued":
-        // Slot hold deliberately KEPT (F13/F2): the task's uncommitted progress
-        // lives in its worktree — re-claim resumes the SAME slot.
-        task.state = "queued"
-        task.ownerWorkerId = null
-        task.verifying = false
-        break
-    }
-  }
+  scanAllToolRequests(): ToolRequest[] { return scanAllToolRequestsFromMap(this.state.toolRequestsById) }
 
-  /**
-   * Apply synchronously, then enqueue the disk append — the sync apply is what
-   * makes an orchestration claim atomic within one event-loop turn (same
-   * pattern as appendSubagentEvent).
-   */
-  appendOrchestrationEvent(event: OrchestrationEvent): Promise<void> {
-    this.applyEvent(event)
-    this.enqueueDiskAppend(this.orchLogPath, `${JSON.stringify(event)}\n`)
-    this.notifyOrchRunsChanged()
-    return Promise.resolve()
-  }
+  async flush(): Promise<void> { await this.writeChain }
 
-  /**
-   * Observe orchestration read-model changes. The callback fires after each
-   * live orch event is applied (not during boot replay — no subscribers yet).
-   * Mirrors the registry `.subscribe()` pattern; used by ws-router to push the
-   * `orch-runs` topic. Returns an unsubscribe fn.
-   */
-  subscribeOrchRuns(cb: () => void): () => void {
-    this.orchRunsSubscribers.add(cb)
-    return () => { this.orchRunsSubscribers.delete(cb) }
-  }
+  private readonly orchSubscriptionState = OrchSubscription.createOrchSubscriptionState()
 
-  private notifyOrchRunsChanged(): void {
-    for (const cb of this.orchRunsSubscribers) {
-      try { cb() } catch (err) { log.warn(`${LOG_PREFIX} orch-runs subscriber threw`, { err }) }
-    }
-  }
+  appendOrchestrationEvent(event: OrchestrationEvent): Promise<void> { return OrchSubscription.appendOrchestrationEvent(this.buildOrchSubscriptionDeps(), event) }
 
-  getOrchRun(runId: string): OrchRunSnapshot | null {
-    const run = this.state.orchRunsById.get(runId)
-    if (!run) return null
-    return this.toOrchRunSnapshot(run)
-  }
+  subscribeOrchRuns(cb: () => void): () => void { return OrchSubscription.subscribeOrchRuns(this.buildOrchSubscriptionDeps(), cb) }
 
-  getOrchRuns(): OrchRunSnapshot[] {
-    return [...this.state.orchRunsById.values()].map((r) => this.toOrchRunSnapshot(r))
-  }
+  getOrchRun(runId: string): OrchRunSnapshot | null { return OrchSubscription.getOrchRun(this.state.orchRunsById, runId) }
 
-  private toOrchRunSnapshot(run: OrchRunRecord): OrchRunSnapshot {
-    const tasks: OrchTaskSnapshot[] = run.taskOrder.flatMap((taskId) => {
-      const t = run.tasksById.get(taskId)
-      if (!t) return []
-      return [{
-        taskId: t.taskId,
-        title: t.title,
-        state: t.state,
-        ownerWorkerId: t.ownerWorkerId,
-        worktreePath: t.worktreePath,
-        branch: t.branch,
-        baseSha: t.baseSha,
-        phaseIndex: t.phaseIndex,
-        attempts: t.attempts,
-        error: t.error,
-        commitSha: t.commitSha,
-        verifying: t.verifying,
-        updatedAt: t.updatedAt,
-      }]
-    })
-    return {
-      runId: run.runId,
-      status: run.status,
-      config: run.config,
-      tasks,
-      worktrees: run.worktrees.map((w) => ({ ...w })),
-      createdAt: run.createdAt,
-      updatedAt: run.updatedAt,
-    }
-  }
+  getOrchRuns(): OrchRunSnapshot[] { return OrchSubscription.getOrchRuns(this.state.orchRunsById) }
 
-  /** Tasks a restart must RE-QUEUE. `gated` is deliberately excluded — a gated task is re-armed in place (gate re-notified), never requeued. */
   *nonTerminalOrchTasks(): Iterable<{ runId: string; taskId: string; state: "claimed" | "running" }> {
-    for (const run of this.state.orchRunsById.values()) {
-      if (run.status !== "running") continue
-      for (const task of run.tasksById.values()) {
-        if (task.state === "claimed" || task.state === "running") {
-          yield { runId: run.runId, taskId: task.taskId, state: task.state }
-        }
-      }
-    }
+    yield* OrchSubscription.nonTerminalOrchTasks(this.state.orchRunsById)
   }
 
-  /** Tasks paused at a hard gate — re-armed (not requeued) by recoverOnStartup. */
   *gatedOrchTasks(): Iterable<{ runId: string; taskId: string; phaseIndex: number }> {
-    for (const run of this.state.orchRunsById.values()) {
-      if (run.status !== "running") continue
-      for (const task of run.tasksById.values()) {
-        if (task.state === "gated") {
-          yield { runId: run.runId, taskId: task.taskId, phaseIndex: task.phaseIndex }
-        }
-      }
-    }
+    yield* OrchSubscription.gatedOrchTasks(this.state.orchRunsById)
   }
 
-  /** Task spec lookup for the engine (records keep prompt/scope; snapshots do not). */
   getOrchTaskSpec(runId: string, taskId: string): { prompt: string; scopePaths: string[] } | null {
-    const task = this.state.orchRunsById.get(runId)?.tasksById.get(taskId)
-    if (!task) return null
-    return { prompt: task.prompt, scopePaths: task.scopePaths }
+    return OrchSubscription.getOrchTaskSpec(this.state.orchRunsById, runId, taskId)
   }
 
-  /** Last completed phase's output — {{PRIOR}} context when resuming a gated/recovered task. */
-  getOrchLastPhaseOutput(runId: string, taskId: string): string | null {
-    return this.state.orchRunsById.get(runId)?.tasksById.get(taskId)?.lastPhaseOutput ?? null
-  }
+  getOrchLastPhaseOutput(runId: string, taskId: string): string | null { return OrchSubscription.getOrchLastPhaseOutput(this.state.orchRunsById, runId, taskId) }
 
-  /** Full ordered event timeline for one run — the rich drill-in source (F8). */
-  getOrchRunEvents(runId: string): OrchestrationEvent[] {
-    return [...(this.state.orchRunsById.get(runId)?.eventLog ?? [])]
-  }
+  getOrchRunEvents(runId: string): OrchestrationEvent[] { return OrchSubscription.getOrchRunEvents(this.state.orchRunsById, runId) }
 }