kaizenai 0.3.0 → 0.4.0

package/src/server/event-store.ts

@@ -1,1470 +0,0 @@
-import { appendFile, mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises"
-import { existsSync, readFileSync as readFileSyncImmediate } from "node:fs"
-import { homedir } from "node:os"
-import path from "node:path"
-import { getDataDir, LOG_PREFIX, PROJECT_METADATA_DIR_NAME } from "../shared/branding"
-import { FEATURE_BROWSER_STATES, FEATURE_STAGES, type AgentProvider, type FeatureBrowserState, type FeatureStage, type TranscriptEntry } from "../shared/types"
-import { STORE_VERSION } from "../shared/types"
-import {
-  type ChatEvent,
-  type FeatureEvent,
-  type MessageEvent,
-  type ProjectEvent,
-  type SnapshotFile,
-  type StoreEvent,
-  type StoreState,
-  type TurnEvent,
-  cloneTranscriptEntries,
-  createEmptyState,
-} from "./events"
-import { resolveProjectRepositoryIdentity, resolveProjectWorktreePaths } from "./git-repository"
-import { resolveLocalPath } from "./paths"
-import { getProjectMetadataDirPath } from "./project-metadata"
-
-const COMPACTION_THRESHOLD_BYTES = 2 * 1024 * 1024
-const FEATURE_METADATA_VERSION = 1 as const
-
-interface PersistedProjectFeature {
-  v: typeof FEATURE_METADATA_VERSION
-  id: string
-  title: string
-  description: string
-  browserState: FeatureBrowserState
-  stage: FeatureStage
-  sortOrder: number
-  directoryRelativePath: string
-  overviewRelativePath: string
-  chatKeys: string[]
-}
-
-interface LegacyTranscriptStats {
-  hasLegacyData: boolean
-  sources: Array<"snapshot" | "messages_log">
-  chatCount: number
-  entryCount: number
-}
-
-export class EventStore {
-  readonly dataDir: string
-  readonly state: StoreState = createEmptyState()
-  private writeChain = Promise.resolve()
-  private storageReset = false
-  private readonly snapshotPath: string
-  private readonly projectsLogPath: string
-  private readonly featuresLogPath: string
-  private readonly chatsLogPath: string
-  private readonly messagesLogPath: string
-  private readonly turnsLogPath: string
-  private readonly transcriptsDir: string
-  private legacyMessagesByChatId = new Map<string, TranscriptEntry[]>()
-  private snapshotHasLegacyMessages = false
-  private cachedTranscripts = new Map<string, TranscriptEntry[]>()
-
-  constructor(dataDir = getDataDir(homedir())) {
-    this.dataDir = dataDir
-    this.snapshotPath = path.join(this.dataDir, "snapshot.json")
-    this.projectsLogPath = path.join(this.dataDir, "projects.jsonl")
-    this.featuresLogPath = path.join(this.dataDir, "features.jsonl")
-    this.chatsLogPath = path.join(this.dataDir, "chats.jsonl")
-    this.messagesLogPath = path.join(this.dataDir, "messages.jsonl")
-    this.turnsLogPath = path.join(this.dataDir, "turns.jsonl")
-    this.transcriptsDir = path.join(this.dataDir, "transcripts")
-  }
-
-  async initialize() {
-    await mkdir(this.dataDir, { recursive: true })
-    await mkdir(this.transcriptsDir, { recursive: true })
-    await this.ensureFile(this.projectsLogPath)
-    await this.ensureFile(this.featuresLogPath)
-    await this.ensureFile(this.chatsLogPath)
-    await this.ensureFile(this.messagesLogPath)
-    await this.ensureFile(this.turnsLogPath)
-    await this.loadSnapshot()
-    await this.replayLogs()
-    this.hydrateProjectWorktrees()
-    await this.reconcileAllProjectFeatureState()
-    if (!(await this.hasLegacyTranscriptData()) && await this.shouldCompact()) {
-      await this.compact()
-    }
-  }
-
-  private hydrateProjectWorktrees() {
-    for (const project of this.state.projectsById.values()) {
-      if (project.deletedAt || !project.repoKey.startsWith("git:")) continue
-      const resolvedPaths = resolveProjectWorktreePaths(project.localPath)
-      for (const worktreePath of resolvedPaths) {
-        if (!project.worktreePaths.includes(worktreePath)) {
-          project.worktreePaths.push(worktreePath)
-        }
-        this.state.projectIdsByPath.set(worktreePath, project.id)
-      }
-    }
-  }
-
-  private async reconcileAllProjectFeatureState() {
-    for (const project of this.state.projectsById.values()) {
-      if (project.deletedAt) continue
-      await this.reconcileProjectFeatureState(project.id)
-    }
-  }
-
-  private async ensureFile(filePath: string) {
-    const file = Bun.file(filePath)
-    if (!(await file.exists())) {
-      await Bun.write(filePath, "")
-    }
-  }
-
-  private async clearStorage() {
-    if (this.storageReset) return
-    this.storageReset = true
-    this.resetState()
-    this.clearLegacyTranscriptState()
-    await Promise.all([
-      Bun.write(this.snapshotPath, ""),
-      Bun.write(this.projectsLogPath, ""),
-      Bun.write(this.featuresLogPath, ""),
-      Bun.write(this.chatsLogPath, ""),
-      Bun.write(this.messagesLogPath, ""),
-      Bun.write(this.turnsLogPath, ""),
-    ])
-  }
-
-  private async loadSnapshot() {
-    const file = Bun.file(this.snapshotPath)
-    if (!(await file.exists())) return
-
-    try {
-      const text = await file.text()
-      if (!text.trim()) return
-      const parsed = JSON.parse(text) as SnapshotFile
-      if (parsed.v !== STORE_VERSION) {
-        console.warn(`${LOG_PREFIX} Resetting local chat history for store version ${STORE_VERSION}`)
-        await this.clearStorage()
-        return
-      }
-      for (const project of parsed.projects) {
-        this.state.projectsById.set(project.id, {
-          ...project,
-          browserState: project.browserState ?? "OPEN",
-          generalChatsBrowserState: project.generalChatsBrowserState ?? "OPEN",
-        })
-        this.state.projectIdsByRepoKey.set(project.repoKey, project.id)
-        for (const worktreePath of project.worktreePaths) {
-          this.state.projectIdsByPath.set(worktreePath, project.id)
-        }
-      }
-      for (const feature of parsed.features ?? []) {
-        this.state.featuresById.set(feature.id, {
-          ...feature,
-          browserState: feature.browserState ?? "OPEN",
-        })
-      }
-      for (const chat of parsed.chats) {
-        this.state.chatsById.set(chat.id, { ...chat })
-      }
-      if (parsed.messages?.length) {
-        this.snapshotHasLegacyMessages = true
-        for (const messageSet of parsed.messages) {
-          this.legacyMessagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
-        }
-      }
-      for (const repoKey of parsed.hiddenProjectKeys ?? []) {
-        this.state.hiddenProjectKeys.add(repoKey)
-      }
-    } catch (error) {
-      console.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, error)
-      await this.clearStorage()
-    }
-  }
-
-  private resetState() {
-    this.state.projectsById.clear()
-    this.state.projectIdsByRepoKey.clear()
-    this.state.projectIdsByPath.clear()
-    this.state.featuresById.clear()
-    this.state.chatsById.clear()
-    this.state.hiddenProjectKeys.clear()
-    this.cachedTranscripts.clear()
-  }
-
-  private clearLegacyTranscriptState() {
-    this.legacyMessagesByChatId.clear()
-    this.snapshotHasLegacyMessages = false
-  }
-
-  private getCachedTranscript(chatId: string) {
-    const cached = this.cachedTranscripts.get(chatId)
-    if (!cached) return null
-    this.cachedTranscripts.delete(chatId)
-    this.cachedTranscripts.set(chatId, cached)
-    return cached
-  }
-
-  private setCachedTranscript(chatId: string, entries: TranscriptEntry[]) {
-    this.cachedTranscripts.set(chatId, entries)
-  }
-
-  private async replayLogs() {
-    if (this.storageReset) return
-    await this.replayLog<ProjectEvent>(this.projectsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<FeatureEvent>(this.featuresLogPath)
-    if (this.storageReset) return
-    await this.replayLog<ChatEvent>(this.chatsLogPath)
-    if (this.storageReset) return
-    await this.replayLog<MessageEvent>(this.messagesLogPath)
-    if (this.storageReset) return
-    await this.replayLog<TurnEvent>(this.turnsLogPath)
-  }
-
-  private async replayLog<TEvent extends StoreEvent>(filePath: string) {
-    const file = Bun.file(filePath)
-    if (!(await file.exists())) return
-    const text = await file.text()
-    if (!text.trim()) return
-
-    const lines = text.split("\n")
-    let lastNonEmpty = -1
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-      if (lines[index].trim()) {
-        lastNonEmpty = index
-        break
-      }
-    }
-
-    for (let index = 0; index < lines.length; index += 1) {
-      const line = lines[index].trim()
-      if (!line) continue
-      try {
-        const event = JSON.parse(line) as Partial<StoreEvent>
-        if (event.v !== STORE_VERSION) {
-          console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
-          await this.clearStorage()
-          return
-        }
-        this.applyEvent(event as StoreEvent)
-      } catch (error) {
-        if (index === lastNonEmpty) {
-          console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
-          return
-        }
-        console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
-        await this.clearStorage()
-        return
-      }
-    }
-  }
-
-  private applyEvent(event: StoreEvent) {
-    switch (event.type) {
-      case "project_opened": {
-        const localPath = resolveLocalPath(event.localPath)
-        const project = {
-          id: event.projectId,
-          repoKey: event.repoKey,
-          localPath,
-          worktreePaths: event.worktreePaths.map((worktreePath) => resolveLocalPath(worktreePath)),
-          title: event.title,
-          browserState: event.browserState ?? "OPEN",
-          generalChatsBrowserState: event.generalChatsBrowserState ?? "OPEN",
-          createdAt: event.timestamp,
-          updatedAt: event.timestamp,
-        }
-        this.state.projectsById.set(project.id, project)
-        this.state.projectIdsByRepoKey.set(project.repoKey, project.id)
-        for (const worktreePath of project.worktreePaths) {
-          this.state.projectIdsByPath.set(worktreePath, project.id)
-        }
-        break
-      }
-      case "project_worktree_added": {
-        const project = this.state.projectsById.get(event.projectId)
-        if (!project) break
-        const localPath = resolveLocalPath(event.localPath)
-        if (!project.worktreePaths.includes(localPath)) {
-          project.worktreePaths.push(localPath)
-        }
-        project.localPath = localPath
-        project.updatedAt = event.timestamp
-        this.state.projectIdsByPath.set(localPath, project.id)
-        break
-      }
-      case "project_browser_state_set": {
-        const project = this.state.projectsById.get(event.projectId)
-        if (!project) break
-        project.browserState = event.browserState
-        project.updatedAt = event.timestamp
-        break
-      }
-      case "project_general_chats_browser_state_set": {
-        const project = this.state.projectsById.get(event.projectId)
-        if (!project) break
-        project.generalChatsBrowserState = event.browserState
-        project.updatedAt = event.timestamp
-        break
-      }
-      case "project_removed": {
-        const project = this.state.projectsById.get(event.projectId)
-        if (!project) break
-        project.deletedAt = event.timestamp
-        project.updatedAt = event.timestamp
-        this.state.projectIdsByRepoKey.delete(project.repoKey)
-        for (const worktreePath of project.worktreePaths) {
-          this.state.projectIdsByPath.delete(worktreePath)
-        }
-        break
-      }
-      case "project_hidden": {
-        this.state.hiddenProjectKeys.add(event.repoKey)
-        break
-      }
-      case "project_unhidden": {
-        this.state.hiddenProjectKeys.delete(event.repoKey)
-        break
-      }
-      case "feature_created": {
-        this.state.featuresById.set(event.featureId, {
-          id: event.featureId,
-          projectId: event.projectId,
-          title: event.title,
-          description: event.description,
-          browserState: event.browserState ?? "OPEN",
-          stage: event.stage,
-          sortOrder: event.sortOrder,
-          directoryRelativePath: event.directoryRelativePath,
-          overviewRelativePath: event.overviewRelativePath,
-          createdAt: event.timestamp,
-          updatedAt: event.timestamp,
-        })
-        break
-      }
-      case "feature_renamed": {
-        const feature = this.state.featuresById.get(event.featureId)
-        if (!feature) break
-        feature.title = event.title
-        if (event.directoryRelativePath) {
-          feature.directoryRelativePath = event.directoryRelativePath
-        }
-        if (typeof event.overviewRelativePath === "string") {
-          feature.overviewRelativePath = event.overviewRelativePath
-        }
-        feature.updatedAt = event.timestamp
-        break
-      }
-      case "feature_browser_state_set": {
-        const feature = this.state.featuresById.get(event.featureId)
-        if (!feature) break
-        feature.browserState = event.browserState
-        feature.updatedAt = event.timestamp
-        break
-      }
-      case "feature_stage_set": {
-        const feature = this.state.featuresById.get(event.featureId)
-        if (!feature) break
-        feature.stage = event.stage
-        if (typeof event.sortOrder === "number") {
-          feature.sortOrder = event.sortOrder
-        }
-        feature.updatedAt = event.timestamp
-        break
-      }
-      case "feature_reordered": {
-        const visibleFeatures = event.orderedFeatureIds
-          .map((featureId) => this.state.featuresById.get(featureId))
-          .filter((feature): feature is NonNullable<typeof feature> => Boolean(feature && !feature.deletedAt))
-
-        visibleFeatures.forEach((feature, index) => {
-          feature.sortOrder = index
-          feature.updatedAt = event.timestamp
-        })
-        break
-      }
-      case "feature_deleted": {
-        const feature = this.state.featuresById.get(event.featureId)
-        if (!feature) break
-        feature.deletedAt = event.timestamp
-        feature.updatedAt = event.timestamp
-        for (const chat of this.state.chatsById.values()) {
-          if (chat.deletedAt || chat.featureId !== event.featureId) continue
-          chat.featureId = null
-          chat.updatedAt = event.timestamp
-        }
-        break
-      }
-      case "feature_overview_updated": {
-        const feature = this.state.featuresById.get(event.featureId)
-        if (!feature) break
-        feature.updatedAt = event.timestamp
-        break
-      }
-      case "chat_created": {
-        const chat = {
-          id: event.chatId,
-          projectId: event.projectId,
-          title: event.title,
-          createdAt: event.timestamp,
-          updatedAt: event.timestamp,
-          featureId: event.featureId ?? null,
-          provider: null,
-          planMode: false,
-          sessionToken: null,
-          lastTurnOutcome: null,
-        }
-        this.state.chatsById.set(chat.id, chat)
-        break
-      }
-      case "chat_renamed": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.title = event.title
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "chat_deleted": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.deletedAt = event.timestamp
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "chat_provider_set": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.provider = event.provider
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "chat_plan_mode_set": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.planMode = event.planMode
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "chat_feature_set": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.featureId = event.featureId
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "message_appended": {
-        this.applyMessageMetadata(event.chatId, event.entry)
-        const existing = this.legacyMessagesByChatId.get(event.chatId) ?? []
-        existing.push({ ...event.entry })
-        this.legacyMessagesByChatId.set(event.chatId, existing)
-        break
-      }
-      case "turn_started": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.updatedAt = event.timestamp
-        break
-      }
-      case "turn_finished": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.updatedAt = event.timestamp
-        chat.lastTurnOutcome = "success"
-        break
-      }
-      case "turn_failed": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.updatedAt = event.timestamp
-        chat.lastTurnOutcome = "failed"
-        break
-      }
-      case "turn_cancelled": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.updatedAt = event.timestamp
-        chat.lastTurnOutcome = "cancelled"
-        break
-      }
-      case "session_token_set": {
-        const chat = this.state.chatsById.get(event.chatId)
-        if (!chat) break
-        chat.sessionToken = event.sessionToken
-        chat.updatedAt = event.timestamp
-        break
-      }
-    }
-  }
-
-  private applyMessageMetadata(chatId: string, entry: TranscriptEntry) {
-    const chat = this.state.chatsById.get(chatId)
-    if (!chat) return
-    if (entry.kind === "user_prompt") {
-      chat.lastMessageAt = entry.createdAt
-    }
-    chat.updatedAt = Math.max(chat.updatedAt, entry.createdAt)
-  }
-
-  private append<TEvent extends StoreEvent>(filePath: string, event: TEvent) {
-    const payload = `${JSON.stringify(event)}\n`
-    this.writeChain = this.writeChain.then(async () => {
-      await appendFile(filePath, payload, "utf8")
-      this.applyEvent(event)
-    })
-    return this.writeChain
-  }
-
-  private transcriptPath(chatId: string) {
-    return path.join(this.transcriptsDir, `${chatId}.jsonl`)
-  }
-
-  private loadTranscriptFromDisk(chatId: string) {
-    const transcriptPath = this.transcriptPath(chatId)
-    if (!existsSync(transcriptPath)) {
-      return []
-    }
-
-    const text = readFileSyncImmediate(transcriptPath, "utf8")
-    if (!text.trim()) return []
-
-    const entries: TranscriptEntry[] = []
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.trim()
-      if (!line) continue
-      entries.push(JSON.parse(line) as TranscriptEntry)
-    }
-    return entries
-  }
-
-  async openProject(localPath: string, title?: string) {
-    const identity = resolveProjectRepositoryIdentity(localPath)
-    const worktreePaths = identity.isGitRepo ? resolveProjectWorktreePaths(identity.worktreePath) : [identity.worktreePath]
-    const existingId = this.state.projectIdsByRepoKey.get(identity.repoKey)
-    if (existingId) {
-      const existing = this.state.projectsById.get(existingId)
-      if (existing && !existing.deletedAt) {
-        const missingWorktreePaths = worktreePaths.filter((worktreePath) => !existing.worktreePaths.includes(worktreePath))
-        for (const missingWorktreePath of missingWorktreePaths) {
-          const event: ProjectEvent = {
-            v: STORE_VERSION,
-            type: "project_worktree_added",
-            timestamp: Date.now(),
-            projectId: existing.id,
-            localPath: missingWorktreePath,
-          }
-          await this.append(this.projectsLogPath, event)
-        }
-        if (existing.localPath !== identity.worktreePath && existing.worktreePaths.includes(identity.worktreePath)) {
-          const event: ProjectEvent = {
-            v: STORE_VERSION,
-            type: "project_worktree_added",
-            timestamp: Date.now(),
-            projectId: existing.id,
-            localPath: identity.worktreePath,
-          }
-          await this.append(this.projectsLogPath, event)
-        }
-        return this.state.projectsById.get(existing.id)!
-      }
-    }
-
-    const projectId = crypto.randomUUID()
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_opened",
-      timestamp: Date.now(),
-      projectId,
-      repoKey: identity.repoKey,
-      localPath: identity.worktreePath,
-      worktreePaths,
-      title: title?.trim() || identity.title,
-      browserState: "OPEN",
-      generalChatsBrowserState: "OPEN",
-    }
-    await this.append(this.projectsLogPath, event)
-    return this.state.projectsById.get(projectId)!
-  }
-
-  async setProjectBrowserState(projectId: string, browserState: FeatureBrowserState) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    if (project.browserState === browserState) return
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_browser_state_set",
-      timestamp: Date.now(),
-      projectId,
-      browserState,
-    }
-    await this.append(this.projectsLogPath, event)
-  }
-
-  async setProjectGeneralChatsBrowserState(projectId: string, browserState: FeatureBrowserState) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    if (project.generalChatsBrowserState === browserState) return
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_general_chats_browser_state_set",
-      timestamp: Date.now(),
-      projectId,
-      browserState,
-    }
-    await this.append(this.projectsLogPath, event)
-  }
-
-  async removeProject(projectId: string) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    if (this.state.hiddenProjectKeys.has(project.repoKey)) return
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_hidden",
-      timestamp: Date.now(),
-      repoKey: project.repoKey,
-    }
-    await this.append(this.projectsLogPath, event)
-  }
-
-  async createFeature(projectId: string, title: string, description = "", generateOverview = true) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    const trimmedTitle = title.trim()
-    const trimmedDescription = description.trim()
-    if (!trimmedTitle) {
-      throw new Error("Feature title is required")
-    }
-
-    const directoryName = this.generateUniqueFeatureDirectoryName(projectId, trimmedTitle)
-    const directoryRelativePath = path.posix.join(PROJECT_METADATA_DIR_NAME, directoryName)
-    const overviewRelativePath = generateOverview ? path.posix.join(directoryRelativePath, "overview.md") : ""
-    const featureDirPath = path.join(project.localPath, directoryRelativePath)
-    const sortOrder = this.getNextFeatureSortOrder(projectId, "idea")
-
-    await mkdir(featureDirPath, { recursive: true })
-    if (generateOverview) {
-      const overviewPath = path.join(project.localPath, overviewRelativePath)
-      await writeFile(overviewPath, this.buildFeatureOverviewContent({
-        projectTitle: project.title,
-        featureTitle: trimmedTitle,
-        description: trimmedDescription,
-      }), "utf8")
-    }
-
-    const featureId = crypto.randomUUID()
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_created",
-      timestamp: Date.now(),
-      featureId,
-      projectId,
-      title: trimmedTitle,
-      description: trimmedDescription,
-      browserState: "OPEN",
-      stage: "idea",
-      sortOrder,
-      directoryRelativePath,
-      overviewRelativePath,
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(projectId)
-    return this.state.featuresById.get(featureId)!
-  }
-
-  async renameFeature(featureId: string, title: string) {
-    const trimmedTitle = title.trim()
-    if (!trimmedTitle) return
-    const feature = this.requireFeature(featureId)
-    if (feature.title === trimmedTitle) return
-
-    const project = this.getProject(feature.projectId)
-    if (!project) throw new Error("Project not found")
-
-    const newDirectoryName = this.generateUniqueFeatureDirectoryName(feature.projectId, trimmedTitle)
-    const newDirectoryRelativePath = path.posix.join(PROJECT_METADATA_DIR_NAME, newDirectoryName)
-    const newOverviewRelativePath = feature.overviewRelativePath
-      ? path.posix.join(newDirectoryRelativePath, "overview.md")
-      : ""
-
-    const oldDirPath = path.join(project.localPath, feature.directoryRelativePath)
-    const newDirPath = path.join(project.localPath, newDirectoryRelativePath)
-
-    try {
-      await rename(oldDirPath, newDirPath)
-    } catch (error: any) {
-      if (error.code !== "ENOENT") throw error
-    }
-
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_renamed",
-      timestamp: Date.now(),
-      featureId,
-      title: trimmedTitle,
-      directoryRelativePath: newDirectoryRelativePath,
-      overviewRelativePath: newOverviewRelativePath,
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(feature.projectId)
-  }
-
-  async setFeatureStage(featureId: string, stage: FeatureStage) {
-    const feature = this.requireFeature(featureId)
-    if (feature.stage === stage) return
-    const shouldRebaseOrder = feature.stage === "done" || stage === "done"
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_stage_set",
-      timestamp: Date.now(),
-      featureId,
-      stage,
-      ...(shouldRebaseOrder
-        ? { sortOrder: this.getRebasedFeatureSortOrder(feature.projectId, featureId, stage) }
-        : {}),
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(feature.projectId, true)
-  }
-
-  async setFeatureBrowserState(featureId: string, browserState: FeatureBrowserState) {
-    const feature = this.requireFeature(featureId)
-    if (feature.browserState === browserState) return
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_browser_state_set",
-      timestamp: Date.now(),
-      featureId,
-      browserState,
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(feature.projectId)
-  }
-
-  async reorderFeatures(projectId: string, orderedFeatureIds: string[]) {
-    const features = this.listFeaturesByProject(projectId)
-    const visibleIds = features.map((feature) => feature.id)
-    if (orderedFeatureIds.length !== visibleIds.length) {
-      throw new Error("Feature reorder payload is incomplete")
-    }
-    const orderedSet = new Set(orderedFeatureIds)
-    if (orderedSet.size !== visibleIds.length || visibleIds.some((id) => !orderedSet.has(id))) {
-      throw new Error("Feature reorder payload does not match project features")
-    }
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_reordered",
-      timestamp: Date.now(),
-      projectId,
-      orderedFeatureIds,
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(projectId)
-  }
-
-  async deleteFeature(featureId: string) {
-    const feature = this.requireFeature(featureId)
-    const project = this.getProject(feature.projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-    await rm(path.join(project.localPath, feature.directoryRelativePath), { recursive: true, force: true })
-    const event: FeatureEvent = {
-      v: STORE_VERSION,
-      type: "feature_deleted",
-      timestamp: Date.now(),
-      featureId,
-    }
-    await this.append(this.featuresLogPath, event)
-    await this.syncProjectFeatureState(feature.projectId)
-  }
-
-  getFeatureOverviewSnapshot(featureId: string) {
-    const feature = this.getFeature(featureId)
-    if (!feature) return null
-    if (!feature.overviewRelativePath) return null
-    const project = this.getProject(feature.projectId)
-    if (!project) return null
-
-    const overviewPath = path.join(project.localPath, feature.overviewRelativePath)
-    const content = existsSync(overviewPath)
-      ? readFileSyncImmediate(overviewPath, "utf8")
-      : this.buildFeatureOverviewContent({
-          projectTitle: project.title,
-          featureTitle: feature.title,
-          description: feature.description,
-        })
-
-    return {
-      featureId: feature.id,
-      projectId: project.id,
-      title: feature.title,
-      directoryRelativePath: feature.directoryRelativePath,
-      overviewRelativePath: feature.overviewRelativePath,
-      localPath: overviewPath,
-      content,
-      updatedAt: feature.updatedAt,
-    }
-  }
-
-  async updateFeatureOverview(featureId: string, content: string) {
-    const feature = this.requireFeature(featureId)
-    if (!feature.overviewRelativePath) {
-      throw new Error("Feature overview is disabled for this feature")
-    }
-    const project = this.getProject(feature.projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-
-    const overviewPath = path.join(project.localPath, feature.overviewRelativePath)
-    await mkdir(path.dirname(overviewPath), { recursive: true })
-    await writeFile(overviewPath, content, "utf8")
-    await this.append(this.featuresLogPath, {
-      v: STORE_VERSION,
-      type: "feature_overview_updated",
-      timestamp: Date.now(),
-      featureId,
-    })
-    await this.syncProjectFeatureState(feature.projectId, true)
-    return this.getFeatureOverviewSnapshot(featureId)
-  }
-
-  async hideProject(localPath: string) {
-    const identity = resolveProjectRepositoryIdentity(localPath)
-    if (this.state.hiddenProjectKeys.has(identity.repoKey)) return
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_hidden",
-      timestamp: Date.now(),
-      repoKey: identity.repoKey,
-    }
-    await this.append(this.projectsLogPath, event)
-  }
-
-  async unhideProject(localPath: string) {
-    const identity = resolveProjectRepositoryIdentity(localPath)
-    if (!this.state.hiddenProjectKeys.has(identity.repoKey)) return
-    const event: ProjectEvent = {
-      v: STORE_VERSION,
-      type: "project_unhidden",
-      timestamp: Date.now(),
-      repoKey: identity.repoKey,
-    }
-    await this.append(this.projectsLogPath, event)
-  }
-
-  async createChat(projectId: string, featureId?: string) {
-    const project = this.state.projectsById.get(projectId)
-    if (!project || project.deletedAt) {
-      throw new Error("Project not found")
-    }
-    if (featureId) {
-      const feature = this.requireFeature(featureId)
-      if (feature.projectId !== projectId) {
-        throw new Error("Feature does not belong to project")
-      }
-    }
-    const chatId = crypto.randomUUID()
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_created",
-      timestamp: Date.now(),
-      chatId,
-      projectId,
-      title: "New Chat",
-      ...(featureId ? { featureId } : {}),
-    }
-    await this.append(this.chatsLogPath, event)
-    return this.state.chatsById.get(chatId)!
-  }
-
-  async renameChat(chatId: string, title: string) {
-    const trimmed = title.trim()
-    if (!trimmed) return
-    const chat = this.requireChat(chatId)
-    if (chat.title === trimmed) return
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_renamed",
-      timestamp: Date.now(),
-      chatId,
-      title: trimmed,
-    }
-    await this.append(this.chatsLogPath, event)
-  }
-
-  async deleteChat(chatId: string) {
-    const chat = this.requireChat(chatId)
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_deleted",
-      timestamp: Date.now(),
-      chatId,
-    }
-    await this.append(this.chatsLogPath, event)
-    await this.syncProjectFeatureState(chat.projectId)
-  }
-
-  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)
-    await this.syncProjectFeatureState(chat.projectId)
-  }
-
-  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 setChatFeature(chatId: string, featureId: string | null) {
-    const chat = this.requireChat(chatId)
-    if (featureId) {
-      const feature = this.requireFeature(featureId)
-      if (feature.projectId !== chat.projectId) {
-        throw new Error("Feature does not belong to the same project")
-      }
-    }
-    if ((chat.featureId ?? null) === featureId) return
-    const event: ChatEvent = {
-      v: STORE_VERSION,
-      type: "chat_feature_set",
-      timestamp: Date.now(),
-      chatId,
-      featureId,
-    }
-    await this.append(this.chatsLogPath, event)
-    await this.syncProjectFeatureState(chat.projectId)
-  }
-
-  async appendMessage(chatId: string, entry: TranscriptEntry) {
-    this.requireChat(chatId)
-    const payload = `${JSON.stringify(entry)}\n`
-    const transcriptPath = this.transcriptPath(chatId)
-    this.writeChain = this.writeChain.then(async () => {
-      await mkdir(this.transcriptsDir, { recursive: true })
-      await appendFile(transcriptPath, payload, "utf8")
-      this.applyMessageMetadata(chatId, entry)
-      const cached = this.cachedTranscripts.get(chatId)
-      if (cached) {
-        cached.push({ ...entry })
-        this.setCachedTranscript(chatId, cached)
-      }
-    })
-    return this.writeChain
-  }
-
-  async recordTurnStarted(chatId: string) {
-    this.requireChat(chatId)
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "turn_started",
-      timestamp: Date.now(),
-      chatId,
-    }
-    await this.append(this.turnsLogPath, event)
-  }
-
-  async recordTurnFinished(chatId: string) {
-    this.requireChat(chatId)
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "turn_finished",
-      timestamp: Date.now(),
-      chatId,
-    }
-    await this.append(this.turnsLogPath, event)
-  }
-
-  async recordTurnFailed(chatId: string, error: string) {
-    this.requireChat(chatId)
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "turn_failed",
-      timestamp: Date.now(),
-      chatId,
-      error,
-    }
-    await this.append(this.turnsLogPath, event)
-  }
-
-  async recordTurnCancelled(chatId: string) {
-    this.requireChat(chatId)
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "turn_cancelled",
-      timestamp: Date.now(),
-      chatId,
-    }
-    await this.append(this.turnsLogPath, event)
-  }
-
-  async setSessionToken(chatId: string, sessionToken: string | null) {
-    const chat = this.requireChat(chatId)
-    if (chat.sessionToken === sessionToken) return
-    const event: TurnEvent = {
-      v: STORE_VERSION,
-      type: "session_token_set",
-      timestamp: Date.now(),
-      chatId,
-      sessionToken,
-    }
-    await this.append(this.turnsLogPath, event)
-    await this.syncProjectFeatureState(chat.projectId)
-  }
-
-  async reconcileProjectFeatureState(projectId: string) {
-    const project = this.getProject(projectId)
-    if (!project) {
-      throw new Error("Project not found")
-    }
-
-    const persistedFeatures = await this.readProjectFeatureMetadata(project.localPath)
-    const existingFeatures = this.listFeaturesByProject(projectId)
-    const existingByDirectory = new Map(
-      existingFeatures.map((feature) => [feature.directoryRelativePath, feature] as const)
-    )
-
-    const chatsByKey = new Map(
-      this.listChatsByProject(projectId)
-        .map((chat) => {
-          const key = this.getChatPersistenceKey(chat)
-          return key ? [key, chat] as const : null
-        })
-        .filter((entry): entry is readonly [string, ReturnType<EventStore["listChatsByProject"]>[number]] => Boolean(entry))
-    )
-
-    let importedFeatures = 0
-    for (const persistedFeature of [...persistedFeatures].sort((a, b) => a.sortOrder - b.sortOrder)) {
-      const existingFeature = existingByDirectory.get(persistedFeature.directoryRelativePath)
-      if (existingFeature) {
-        continue
-      }
-      const featureId = persistedFeature.id
-      const timestamp = Date.now()
-      const event: FeatureEvent = {
-        v: STORE_VERSION,
-        type: "feature_created",
-        timestamp,
-        featureId,
-        projectId,
-        title: persistedFeature.title,
-        description: persistedFeature.description,
-        browserState: persistedFeature.browserState,
-        stage: persistedFeature.stage,
-        sortOrder: persistedFeature.sortOrder,
-        directoryRelativePath: persistedFeature.directoryRelativePath,
-        overviewRelativePath: persistedFeature.overviewRelativePath,
-      }
-      await this.append(this.featuresLogPath, event)
-      importedFeatures += 1
-
-      for (const chatKey of persistedFeature.chatKeys) {
-        const chat = chatsByKey.get(chatKey)
-        if (!chat) continue
-        const assignmentEvent: ChatEvent = {
-          v: STORE_VERSION,
-          type: "chat_feature_set",
-          timestamp: Date.now(),
-          chatId: chat.id,
-          featureId,
-        }
-        await this.append(this.chatsLogPath, assignmentEvent)
-      }
-    }
-
-    await this.syncProjectFeatureState(projectId, true)
-    return importedFeatures
-  }
-
-  getProject(projectId: string) {
-    const project = this.state.projectsById.get(projectId)
-    if (!project || project.deletedAt) return null
-    return project
-  }
-
-  requireFeature(featureId: string) {
-    const feature = this.state.featuresById.get(featureId)
-    if (!feature || feature.deletedAt) {
-      throw new Error("Feature not found")
-    }
-    return feature
-  }
-
-  getFeature(featureId: string) {
-    const feature = this.state.featuresById.get(featureId)
-    if (!feature || feature.deletedAt) return null
-    return feature
-  }
-
-  requireChat(chatId: string) {
-    const chat = this.state.chatsById.get(chatId)
-    if (!chat || chat.deletedAt) {
-      throw new Error("Chat not found")
-    }
-    return chat
-  }
-
-  getChat(chatId: string) {
-    const chat = this.state.chatsById.get(chatId)
-    if (!chat || chat.deletedAt) return null
-    return chat
-  }
-
-  getMessages(chatId: string) {
-    const cached = this.getCachedTranscript(chatId)
-    if (cached) {
-      return cloneTranscriptEntries(cached)
-    }
-
-    const legacyEntries = this.legacyMessagesByChatId.get(chatId)
-    if (legacyEntries) {
-      const clonedLegacyEntries = cloneTranscriptEntries(legacyEntries)
-      this.setCachedTranscript(chatId, clonedLegacyEntries)
-      return cloneTranscriptEntries(clonedLegacyEntries)
-    }
-
-    const entries = this.loadTranscriptFromDisk(chatId)
-    this.setCachedTranscript(chatId, entries)
-    return cloneTranscriptEntries(entries)
-  }
-
-  listProjects() {
-    return [...this.state.projectsById.values()].filter((project) => !project.deletedAt)
-  }
-
-  listFeaturesByProject(projectId: string) {
-    return [...this.state.featuresById.values()]
-      .filter((feature) => feature.projectId === projectId && !feature.deletedAt)
-      .sort((a, b) => {
-        const aDone = a.stage === "done" ? 1 : 0
-        const bDone = b.stage === "done" ? 1 : 0
-        if (aDone !== bDone) return aDone - bDone
-        if (a.sortOrder !== b.sortOrder) return a.sortOrder - b.sortOrder
-        return b.updatedAt - a.updatedAt
-      })
-  }
-
-  isProjectHidden(repoKey: string) {
-    return this.state.hiddenProjectKeys.has(repoKey)
-  }
-
-  listChatsByProject(projectId: string) {
-    return [...this.state.chatsById.values()]
-      .filter((chat) => chat.projectId === projectId && !chat.deletedAt)
-      .sort((a, b) => (b.lastMessageAt ?? b.updatedAt) - (a.lastMessageAt ?? a.updatedAt))
-  }
-
-  getChatCount(projectId: string) {
-    return this.listChatsByProject(projectId).length
-  }
-
-  async getLegacyTranscriptStats(): Promise<LegacyTranscriptStats> {
-    const messagesLogSize = await Bun.file(this.messagesLogPath).size
-    const sources: LegacyTranscriptStats["sources"] = []
-    if (this.snapshotHasLegacyMessages) {
-      sources.push("snapshot")
-    }
-    if (messagesLogSize > 0) {
-      sources.push("messages_log")
-    }
-
-    let entryCount = 0
-    for (const entries of this.legacyMessagesByChatId.values()) {
-      entryCount += entries.length
-    }
-
-    return {
-      hasLegacyData: sources.length > 0 || this.legacyMessagesByChatId.size > 0,
-      sources,
-      chatCount: this.legacyMessagesByChatId.size,
-      entryCount,
-    }
-  }
-
-  async hasLegacyTranscriptData() {
-    return (await this.getLegacyTranscriptStats()).hasLegacyData
-  }
-
-  private createSnapshot(includeLegacyMessages: boolean): SnapshotFile {
-    const snapshot: SnapshotFile = {
-      v: STORE_VERSION,
-      generatedAt: Date.now(),
-      projects: this.listProjects().map((project) => ({ ...project })),
-      features: [...this.state.featuresById.values()]
-        .filter((feature) => !feature.deletedAt)
-        .map((feature) => ({ ...feature })),
-      chats: [...this.state.chatsById.values()]
-        .filter((chat) => !chat.deletedAt)
-        .map((chat) => ({ ...chat })),
-      hiddenProjectKeys: [...this.state.hiddenProjectKeys.values()],
-    }
-
-    if (includeLegacyMessages) {
-      snapshot.messages = [...this.legacyMessagesByChatId.entries()].map(([chatId, entries]) => ({
-        chatId,
-        entries: cloneTranscriptEntries(entries),
-      }))
-    }
-
-    return snapshot
-  }
-
-  async compact() {
-    await this.writeChain
-    const snapshot = this.createSnapshot(false)
-    const tmpPath = `${this.snapshotPath}.tmp`
-    await Bun.write(tmpPath, JSON.stringify(snapshot, null, 2))
-    await rename(tmpPath, this.snapshotPath)
-    await Promise.all([
-      Bun.write(this.projectsLogPath, ""),
-      Bun.write(this.featuresLogPath, ""),
-      Bun.write(this.chatsLogPath, ""),
-      Bun.write(this.messagesLogPath, ""),
-      Bun.write(this.turnsLogPath, ""),
-    ])
-  }
-
-  private async compactLegacyMessagesIntoSnapshot() {
-    const snapshot = this.createSnapshot(true)
-    await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
-    await Promise.all([
-      Bun.write(this.projectsLogPath, ""),
-      Bun.write(this.chatsLogPath, ""),
-      Bun.write(this.messagesLogPath, ""),
-      Bun.write(this.turnsLogPath, ""),
-    ])
-  }
-
-  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}`)
-    onProgress?.(`${LOG_PREFIX} transcript migration: compacting legacy transcript state into snapshot`)
-    await this.compactLegacyMessagesIntoSnapshot()
-
-    const snapshot = JSON.parse(await readFile(this.snapshotPath, "utf8")) as SnapshotFile
-    const messageSets = snapshot.messages ?? []
-    onProgress?.(`${LOG_PREFIX} transcript migration: writing ${messageSets.length} per-chat transcript files`)
-
-    await mkdir(this.transcriptsDir, { recursive: true })
-    const logEveryChat = messageSets.length <= 10
-    for (let index = 0; index < messageSets.length; index += 1) {
-      const { chatId, entries } = messageSets[index]
-      const transcriptPath = this.transcriptPath(chatId)
-      const tempPath = `${transcriptPath}.tmp`
-      const payload = entries.map((entry) => JSON.stringify(entry)).join("\n")
-      await writeFile(tempPath, payload ? `${payload}\n` : "", "utf8")
-      await rename(tempPath, transcriptPath)
-      if (logEveryChat || (index + 1) % 25 === 0 || index === messageSets.length - 1) {
-        onProgress?.(`${LOG_PREFIX} transcript migration: ${index + 1}/${messageSets.length} chats`)
-      }
-    }
-
-    delete snapshot.messages
-    await Bun.write(this.snapshotPath, JSON.stringify(snapshot, null, 2))
-    this.clearLegacyTranscriptState()
-    this.cachedTranscripts.clear()
-    onProgress?.(`${LOG_PREFIX} transcript migration complete`)
-    return true
-  }
-
-  private async shouldCompact() {
-    const sizes = await Promise.all([
-      Bun.file(this.projectsLogPath).size,
-      Bun.file(this.featuresLogPath).size,
-      Bun.file(this.chatsLogPath).size,
-      Bun.file(this.messagesLogPath).size,
-      Bun.file(this.turnsLogPath).size,
-    ])
-    return sizes.reduce((total, size) => total + size, 0) >= COMPACTION_THRESHOLD_BYTES
-  }
-
-  private generateUniqueFeatureDirectoryName(projectId: string, title: string) {
-    const normalizedBase = title
-      .trim()
-      .replace(/\s+/g, "_")
-      .replace(/[^A-Za-z0-9_-]/g, "")
-      .replace(/_+/g, "_")
-      || "feature"
-    const existing = new Set(
-      this.listFeaturesByProject(projectId).map((feature) => path.posix.basename(feature.directoryRelativePath))
-    )
-    if (!existing.has(normalizedBase)) return normalizedBase
-    let index = 2
-    while (existing.has(`${normalizedBase}_${index}`)) {
-      index += 1
-    }
-    return `${normalizedBase}_${index}`
-  }
-
-  private getNextFeatureSortOrder(projectId: string, stage: FeatureStage) {
-    const features = this.listFeaturesByProject(projectId)
-    if (stage === "done") {
-      const doneOrders = features.filter((feature) => feature.stage === "done").map((feature) => feature.sortOrder)
-      return doneOrders.length === 0 ? features.length : Math.max(...doneOrders) + 1
-    }
-    const nonDoneOrders = features.filter((feature) => feature.stage !== "done").map((feature) => feature.sortOrder)
-    return nonDoneOrders.length === 0 ? 0 : Math.max(...nonDoneOrders) + 1
-  }
-
-  private getRebasedFeatureSortOrder(projectId: string, featureId: string, nextStage: FeatureStage) {
-    const features = this.listFeaturesByProject(projectId).filter((feature) => feature.id !== featureId)
-    if (nextStage === "done") {
-      const doneOrders = features.filter((feature) => feature.stage === "done").map((feature) => feature.sortOrder)
-      const maxOverall = features.map((feature) => feature.sortOrder)
-      return doneOrders.length > 0
-        ? Math.max(...doneOrders) + 1
-        : maxOverall.length > 0
-          ? Math.max(...maxOverall) + 1
-          : 0
-    }
-    const nonDoneOrders = features.filter((feature) => feature.stage !== "done").map((feature) => feature.sortOrder)
-    return nonDoneOrders.length === 0 ? 0 : Math.max(...nonDoneOrders) + 1
-  }
-
-  private buildFeatureOverviewContent(args: {
-    projectTitle: string
-    featureTitle: string
-    description: string
-  }) {
-    const summary = args.description.trim() || "TODO: Add a short summary for this feature."
-    return [
-      `# ${args.featureTitle}`,
-      "",
-      `Project: ${args.projectTitle}`,
-      "",
-      "## Summary",
-      summary,
-      "",
-      "## Notes",
-      "- Initial feature overview generated at creation time.",
-      "- Replace this with a fuller implementation plan as the feature evolves.",
-      "",
-      "## Open Questions",
-      "- Scope details",
-      "- Technical approach",
-      "- Testing strategy",
-      "",
-    ].join("\n")
-  }
-
-  private getFeatureMetadataPath(localPath: string, directoryRelativePath: string) {
-    return path.join(localPath, directoryRelativePath, "feature.json")
-  }
-
-  private getChatPersistenceKey(chat: {
-    provider: AgentProvider | null
-    sessionToken: string | null
-  }) {
-    if (!chat.provider || !chat.sessionToken) return null
-    return `${chat.provider}:${chat.sessionToken}`
-  }
-
-  private async syncProjectFeatureState(projectId: string, force = false) {
-    const project = this.getProject(projectId)
-    if (!project) return
-    if (!force && this.listFeaturesByProject(projectId).length === 0) {
-      return
-    }
-
-    for (const feature of this.listFeaturesByProject(projectId)) {
-      const persistedFeature: PersistedProjectFeature = {
-        v: FEATURE_METADATA_VERSION,
-        id: feature.id,
-        title: feature.title,
-        description: feature.description,
-        browserState: feature.browserState,
-        stage: feature.stage,
-        sortOrder: feature.sortOrder,
-        directoryRelativePath: feature.directoryRelativePath,
-        overviewRelativePath: feature.overviewRelativePath,
-        chatKeys: this.listChatsByProject(projectId)
-          .filter((chat) => chat.featureId === feature.id)
-          .map((chat) => this.getChatPersistenceKey(chat))
-          .filter((chatKey): chatKey is string => Boolean(chatKey)),
-      }
-      const featureMetadataPath = this.getFeatureMetadataPath(project.localPath, feature.directoryRelativePath)
-      await mkdir(path.dirname(featureMetadataPath), { recursive: true })
-      if (feature.overviewRelativePath) {
-        const overviewPath = path.join(project.localPath, feature.overviewRelativePath)
-        await mkdir(path.dirname(overviewPath), { recursive: true })
-        if (!existsSync(overviewPath)) {
-          await writeFile(overviewPath, this.buildFeatureOverviewContent({
-            projectTitle: project.title,
-            featureTitle: feature.title,
-            description: feature.description,
-          }), "utf8")
-        }
-      }
-      await writeFile(featureMetadataPath, JSON.stringify(persistedFeature, null, 2), "utf8")
-    }
-  }
-
-  private async readProjectFeatureMetadata(localPath: string): Promise<PersistedProjectFeature[]> {
-    try {
-      const metadataDir = getProjectMetadataDirPath(localPath)
-      const entries = await readdir(metadataDir, { withFileTypes: true })
-      const features: PersistedProjectFeature[] = []
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        const raw = await readFile(path.join(metadataDir, entry.name, "feature.json"), "utf8").catch(() => null)
-        if (!raw?.trim()) continue
-        const parsed = JSON.parse(raw) as Partial<PersistedProjectFeature>
-        if (
-          ((parsed.v as number | undefined) !== 1 && parsed.v !== FEATURE_METADATA_VERSION)
-          || typeof parsed.title !== "string"
-          || typeof parsed.description !== "string"
-          || typeof parsed.directoryRelativePath !== "string"
-          || typeof parsed.overviewRelativePath !== "string"
-          || typeof parsed.sortOrder !== "number"
-          || !FEATURE_BROWSER_STATES.includes((parsed.browserState ?? "OPEN") as FeatureBrowserState)
-          || !FEATURE_STAGES.includes(parsed.stage as FeatureStage)
-        ) {
-          continue
-        }
-        features.push({
-          v: FEATURE_METADATA_VERSION,
-          id: typeof parsed.id === "string" && parsed.id.trim() ? parsed.id : crypto.randomUUID(),
-          title: parsed.title,
-          description: parsed.description,
-          browserState: (parsed.browserState ?? "OPEN") as FeatureBrowserState,
-          stage: parsed.stage as FeatureStage,
-          sortOrder: parsed.sortOrder,
-          directoryRelativePath: parsed.directoryRelativePath,
-          overviewRelativePath: parsed.overviewRelativePath,
-          chatKeys: Array.isArray(parsed.chatKeys)
-            ? parsed.chatKeys.filter((chatKey): chatKey is string => typeof chatKey === "string")
-            : [],
-        })
-      }
-
-      return features
-    } catch {
-      return []
-    }
-  }
-}