zyflow 0.6.4

package/server/parser.ts

@@ -0,0 +1,342 @@
+import type { TaskGroup, Task, TasksFile } from '../src/types/index.js'
+
+/**
+ * Extended TaskGroup with hierarchy info for 3-level structure
+ * ## 1. Major Section (majorOrder=1, majorTitle="데이터베이스 및 기반")
+ * ### 1.1 Sub Section (majorOrder=1, subOrder=1, title="1.1 DB 스키마 확장")
+ * - [ ] 1.1.1 Task (taskOrder=1)
+ */
+interface ExtendedTaskGroup extends TaskGroup {
+  majorOrder?: number    // "## 1." -> 1
+  majorTitle?: string    // "## 1. 데이터베이스 및 기반" -> "데이터베이스 및 기반"
+  subOrder?: number      // "### 1.1" -> 1 (second part)
+  groupTitle?: string    // 그룹 제목 (title과 동일하지만 명시적)
+  groupOrder?: number    // 그룹 순서 (majorOrder와 동일하지만 명시적)
+}
+
+/**
+ * Parse tasks.md content into structured data
+ *
+ * Supports multiple formats:
+ * - 3-level: "## 1. Major" > "### 1.1 Sub" > "- [ ] 1.1.1 Task"
+ * - 2-level: "## 1. Section" > "- [ ] Task"
+ * - Phase: "## Phase 0:" > "### 0.1 Sub" > "- [ ] 0.1.1 Task"
+ * - Plain: "## Section" > "- [ ] Task"
+ * - 4-level headers: "#### 1.1 Sub" treated as subsection
+ */
+export function parseTasksFile(changeId: string, content: string): TasksFile {
+  return parseTasksFileOriginal(changeId, content)
+}
+
+/**
+ * 기존 파서 로직 (fallback용)
+ */
+function parseTasksFileOriginal(changeId: string, content: string): TasksFile {
+  const lines = content.split('\n')
+  const groups: ExtendedTaskGroup[] = []
+  let currentGroup: ExtendedTaskGroup | null = null
+  let currentMajorOrder = 0
+  let currentMajorTitle = ''
+  let groupCounter = 0
+  let taskCounter = 0
+  // Track if we have a pending major section without subsections
+  let pendingMajorGroup: ExtendedTaskGroup | null = null
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const lineNumber = i + 1
+
+    // Match major group headers: "## 1. Section Name"
+    const numberedGroupMatch = line.match(/^##\s+(\d+)\.\s+(.+)$/)
+    // Match phase format: "## Phase 0: Section Name"
+    const phaseGroupMatch = line.match(/^##\s+Phase\s+(\d+):\s*(.+)$/i)
+    // Match plain format: "## Section Name" (not starting with #)
+    const plainGroupMatch = line.match(/^##\s+([^#].*)$/)
+
+    // Match subsection headers: "### 1.1 Subsection" or "#### 1.1 Subsection"
+    const subsectionMatch = line.match(/^#{3,4}\s+([\d.]+)\s+(.+)$/)
+    // Match plain subsection: "### Subsection Name" (no number)
+    const plainSubsectionMatch = line.match(/^###\s+([^#\d].*)$/)
+
+    if (numberedGroupMatch) {
+      // Flush pending major group if it has tasks
+      if (pendingMajorGroup && pendingMajorGroup.tasks.length > 0) {
+        groups.push(pendingMajorGroup)
+      }
+
+      currentMajorOrder = parseInt(numberedGroupMatch[1])
+      currentMajorTitle = numberedGroupMatch[2].trim()
+
+      // Create a pending group for tasks that come directly under ##
+      const groupId = `group-${currentMajorOrder}`
+      pendingMajorGroup = {
+        id: groupId,
+        title: currentMajorTitle,
+        tasks: [],
+        majorOrder: currentMajorOrder,
+        majorTitle: currentMajorTitle,
+        subOrder: 1,
+        groupTitle: currentMajorTitle,
+        groupOrder: currentMajorOrder
+      }
+      currentGroup = pendingMajorGroup
+      taskCounter = 0
+      continue
+    }
+
+    if (phaseGroupMatch) {
+      // Flush pending major group
+      if (pendingMajorGroup && pendingMajorGroup.tasks.length > 0) {
+        groups.push(pendingMajorGroup)
+      }
+
+      currentMajorOrder = parseInt(phaseGroupMatch[1])
+      currentMajorTitle = `Phase ${phaseGroupMatch[1]}: ${phaseGroupMatch[2].trim()}`
+
+      // Create pending group for Phase
+      const groupId = `group-phase-${phaseGroupMatch[1]}`
+      pendingMajorGroup = {
+        id: groupId,
+        title: currentMajorTitle,
+        tasks: [],
+        majorOrder: currentMajorOrder,
+        majorTitle: currentMajorTitle,
+        subOrder: 1,
+        groupTitle: currentMajorTitle,
+        groupOrder: currentMajorOrder
+      }
+      currentGroup = pendingMajorGroup
+      taskCounter = 0
+      continue
+    }
+
+    // Subsection with number: "### 1.1 Name" or "#### 1.1 Name"
+    if (subsectionMatch) {
+      // If we have a pending major group, add it before processing subsections
+      if (pendingMajorGroup) {
+        groups.push(pendingMajorGroup)
+        pendingMajorGroup = null
+      }
+
+      const subsectionNumber = subsectionMatch[1] // "1.1" or "0.1" or "1."
+      const parts = subsectionNumber.split('.')
+      const majorNum = parseInt(parts[0]) // 1 or 0
+      // Handle trailing dot case: "1." splits to ["1", ""] - parseInt("") returns NaN
+      const subNum = parts.length > 1 && parts[1] ? parseInt(parts[1]) : 1
+
+      // Use current major info if available, otherwise derive from subsection number
+      const effectiveMajorOrder = currentMajorOrder !== 0 || currentMajorTitle ? currentMajorOrder : majorNum
+      const effectiveMajorTitle = currentMajorTitle || `Section ${majorNum}`
+
+      const groupId = `group-${subsectionNumber.replace(/\./g, '-')}`
+      const groupTitle = `${subsectionNumber} ${subsectionMatch[2].trim()}`
+
+      currentGroup = {
+        id: groupId,
+        title: groupTitle,
+        tasks: [],
+        majorOrder: effectiveMajorOrder,
+        majorTitle: effectiveMajorTitle,
+        subOrder: subNum,
+        groupTitle: groupTitle,
+        groupOrder: effectiveMajorOrder
+      }
+      groups.push(currentGroup)
+      taskCounter = 0
+      continue
+    }
+
+    // Plain subsection: "### Subsection Name" (no number)
+    // These are often just labels/headers without tasks (e.g., "### 준비 작업 (Week 1)")
+    // Don't create a group for them - just update context for any #### subsections that follow
+    if (plainSubsectionMatch && !subsectionMatch) {
+      // Flush pending major group if needed
+      if (pendingMajorGroup && pendingMajorGroup.tasks.length > 0) {
+        groups.push(pendingMajorGroup)
+      }
+      pendingMajorGroup = null
+
+      // Don't create a group - just skip this header
+      // Tasks that follow will be captured by #### subsections or numbered tasks
+      taskCounter = 0
+      continue
+    }
+
+    // Plain ## header (fallback) - "## Section Name"
+    if (plainGroupMatch && !numberedGroupMatch && !phaseGroupMatch) {
+      if (line.startsWith('# ') && !line.startsWith('## ')) continue
+
+      // Flush pending major group
+      if (pendingMajorGroup && pendingMajorGroup.tasks.length > 0) {
+        groups.push(pendingMajorGroup)
+      }
+
+      groupCounter++
+      currentMajorOrder = groupCounter
+      currentMajorTitle = plainGroupMatch[1].trim()
+
+      const groupId = `group-${groupCounter}`
+      pendingMajorGroup = {
+        id: groupId,
+        title: currentMajorTitle,
+        tasks: [],
+        majorOrder: currentMajorOrder,
+        majorTitle: currentMajorTitle,
+        subOrder: 1,
+        groupTitle: currentMajorTitle,
+        groupOrder: currentMajorOrder
+      }
+      currentGroup = pendingMajorGroup
+      taskCounter = 0
+      continue
+    }
+
+    // Match task items - two formats:
+    // 1. "- [ ] 1.1.1 Task" - numbered task
+    // 2. "- [ ] Task" - unnumbered task (auto-generate ID)
+    const numberedTaskMatch = line.match(/^-\s+\[([ xX])\]\s+([\d.]+)\s+(.+)$/)
+    const plainTaskMatch = line.match(/^-\s+\[([ xX])\]\s+(.+)$/)
+
+    if (numberedTaskMatch && currentGroup) {
+      const completed = numberedTaskMatch[1].toLowerCase() === 'x'
+      const taskNumber = numberedTaskMatch[2]
+      const taskTitle = numberedTaskMatch[3].trim()
+      const taskId = `task-${taskNumber.replace(/\./g, '-')}`
+
+      const task: Task = {
+        id: taskId,
+        title: taskTitle,
+        completed,
+        groupId: currentGroup.id,
+        lineNumber,
+      }
+
+      currentGroup.tasks.push(task)
+      taskCounter++
+    } else if (plainTaskMatch && currentGroup && !numberedTaskMatch) {
+      const completed = plainTaskMatch[1].toLowerCase() === 'x'
+      const taskTitle = plainTaskMatch[2].trim()
+      taskCounter++
+      const taskId = `task-${currentGroup.id}-${taskCounter}`
+
+      const task: Task = {
+        id: taskId,
+        title: taskTitle,
+        completed,
+        groupId: currentGroup.id,
+        lineNumber,
+      }
+
+      currentGroup.tasks.push(task)
+    }
+  }
+
+  // Flush any remaining pending group
+  if (pendingMajorGroup) {
+    groups.push(pendingMajorGroup)
+  }
+
+  return { changeId, groups }
+}
+
+/**
+ * Toggle task completion status in file content
+ */
+export function toggleTaskInFile(
+  content: string,
+  taskId: string
+): { newContent: string; task: Task } {
+  const lines = content.split('\n')
+
+  let foundTask: Task | null = null
+  let currentGroupId = ''
+  let groupCounter = 0
+  let taskCounter = 0
+
+  // Check if taskId is numbered (task-1-1) or auto-generated (task-group-xxx-n)
+  const isNumberedTask = /^task-[\d-]+$/.test(taskId) && !taskId.includes('group')
+  const taskNumber = isNumberedTask
+    ? taskId.replace('task-', '').replace(/-/g, '.')
+    : null
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // Track current group - multiple formats
+    const numberedGroupMatch = line.match(/^##\s+(\d+)\.\s+(.+)$/)
+    const phaseGroupMatch = line.match(/^##\s+Phase\s+(\d+):\s*(.+)$/i)
+    const subsectionMatch = line.match(/^###\s+([\d.]+)\s+(.+)$/)
+    const plainGroupMatch = line.match(/^##\s+(.+)$/)
+
+    if (numberedGroupMatch) {
+      currentGroupId = `group-${numberedGroupMatch[1]}`
+      taskCounter = 0
+    } else if (phaseGroupMatch) {
+      currentGroupId = `group-phase-${phaseGroupMatch[1]}`
+      taskCounter = 0
+    } else if (subsectionMatch) {
+      currentGroupId = `group-${subsectionMatch[1].replace(/\./g, '-')}`
+      taskCounter = 0
+    } else if (plainGroupMatch && !numberedGroupMatch && !phaseGroupMatch && !line.startsWith('# ')) {
+      groupCounter++
+      currentGroupId = `group-${groupCounter}`
+      taskCounter = 0
+    }
+
+    // Try numbered task match first
+    const numberedTaskMatch = line.match(/^(-\s+\[)([ xX])(\]\s+)([\d.]+)(\s+.+)$/)
+    if (numberedTaskMatch) {
+      taskCounter++
+      if (isNumberedTask && numberedTaskMatch[4] === taskNumber) {
+        const wasCompleted = numberedTaskMatch[2].toLowerCase() === 'x'
+        const newCompleted = !wasCompleted
+        const newCheckmark = newCompleted ? 'x' : ' '
+
+        lines[i] = `${numberedTaskMatch[1]}${newCheckmark}${numberedTaskMatch[3]}${numberedTaskMatch[4]}${numberedTaskMatch[5]}`
+
+        foundTask = {
+          id: taskId,
+          title: numberedTaskMatch[5].trim(),
+          completed: newCompleted,
+          groupId: currentGroupId,
+          lineNumber: i + 1,
+        }
+        break
+      }
+      continue
+    }
+
+    // Try plain task match (unnumbered)
+    const plainTaskMatch = line.match(/^(-\s+\[)([ xX])(\]\s+)(.+)$/)
+    if (plainTaskMatch && currentGroupId) {
+      taskCounter++
+      const generatedTaskId = `task-${currentGroupId}-${taskCounter}`
+
+      if (!isNumberedTask && generatedTaskId === taskId) {
+        const wasCompleted = plainTaskMatch[2].toLowerCase() === 'x'
+        const newCompleted = !wasCompleted
+        const newCheckmark = newCompleted ? 'x' : ' '
+
+        lines[i] = `${plainTaskMatch[1]}${newCheckmark}${plainTaskMatch[3]}${plainTaskMatch[4]}`
+
+        foundTask = {
+          id: taskId,
+          title: plainTaskMatch[4].trim(),
+          completed: newCompleted,
+          groupId: currentGroupId,
+          lineNumber: i + 1,
+        }
+        break
+      }
+    }
+  }
+
+  if (!foundTask) {
+    throw new Error(`Task not found: ${taskId}`)
+  }
+
+  return {
+    newContent: lines.join('\n'),
+    task: foundTask,
+  }
+}

package/server/remote-watcher.ts

@@ -0,0 +1,367 @@
+/**
+ * Remote File Watcher for SSH projects
+ * 원격 프로젝트의 tasks.md 파일 변경을 폴링으로 감지하고 DB 동기화 및 WebSocket 알림
+ */
+
+import { join } from 'path'
+import type { WSEvent } from './websocket.js'
+import { broadcast } from './websocket.js'
+import { syncRemoteChangeTasksForProject } from './sync-tasks.js'
+
+// Polling intervals (ms)
+const POLL_INTERVAL_MIN = 10_000     // 10 seconds (burst mode)
+const POLL_INTERVAL_DEFAULT = 30_000 // 30 seconds (normal mode)
+const POLL_INTERVAL_MAX = 60_000     // 60 seconds (idle mode)
+const BURST_MODE_DURATION = 120_000  // 2 minutes in burst mode after change detected
+const IDLE_THRESHOLD = 300_000       // 5 minutes without changes -> idle mode
+
+interface WatchedProject {
+  projectId: string
+  projectPath: string
+  serverId: string
+  mtimeCache: Map<string, number>  // changeId -> mtime (ms)
+  pollInterval: number
+  timer: NodeJS.Timeout | null
+  lastChangeAt: number
+  lastPollAt: number
+  errorCount: number
+}
+
+const watchedProjects = new Map<string, WatchedProject>()
+
+// Remote plugin functions (loaded dynamically)
+let remotePlugin: {
+  getRemoteServerById: (serverId: string) => Promise<unknown>
+  listDirectory: (server: unknown, path: string) => Promise<{ entries: Array<{ name: string; type: string }> }>
+  readRemoteFile: (server: unknown, path: string) => Promise<string>
+  getSFTP: (server: unknown) => Promise<{ stat: (path: string) => Promise<{ mtime: number }> }>
+} | null = null
+
+async function loadRemotePlugin() {
+  if (remotePlugin) return remotePlugin
+
+  try {
+    const plugin = await import('@zyflow/remote-plugin')
+    remotePlugin = {
+      getRemoteServerById: plugin.getRemoteServerById,
+      listDirectory: plugin.listDirectory,
+      readRemoteFile: plugin.readRemoteFile,
+      getSFTP: plugin.getSFTP,
+    }
+    return remotePlugin
+  } catch {
+    console.error('[RemoteWatcher] Remote plugin not installed')
+    return null
+  }
+}
+
+/**
+ * Start watching a remote project for tasks.md changes
+ */
+export async function startRemoteWatcher(
+  project: { id: string; path: string },
+  serverId: string
+): Promise<void> {
+  // Stop existing watcher for this project if any
+  if (watchedProjects.has(project.id)) {
+    stopRemoteWatcher(project.id)
+  }
+
+  const plugin = await loadRemotePlugin()
+  if (!plugin) {
+    console.log('[RemoteWatcher] Cannot start - remote plugin not available')
+    return
+  }
+
+  const state: WatchedProject = {
+    projectId: project.id,
+    projectPath: project.path,
+    serverId,
+    mtimeCache: new Map(),
+    pollInterval: POLL_INTERVAL_DEFAULT,
+    timer: null,
+    lastChangeAt: 0,
+    lastPollAt: 0,
+    errorCount: 0,
+  }
+
+  watchedProjects.set(project.id, state)
+
+  console.log(`[RemoteWatcher] Started watching project: ${project.id}`)
+
+  // Start first poll immediately
+  await pollRemoteChanges(state)
+
+  // Schedule next poll
+  scheduleNextPoll(state)
+}
+
+/**
+ * Stop watching a remote project
+ */
+export function stopRemoteWatcher(projectId: string): void {
+  const state = watchedProjects.get(projectId)
+  if (state) {
+    if (state.timer) {
+      clearTimeout(state.timer)
+      state.timer = null
+    }
+    watchedProjects.delete(projectId)
+    console.log(`[RemoteWatcher] Stopped watching project: ${projectId}`)
+  }
+}
+
+/**
+ * Stop all remote watchers
+ */
+export function stopAllRemoteWatchers(): void {
+  for (const [projectId] of watchedProjects) {
+    stopRemoteWatcher(projectId)
+  }
+  console.log('[RemoteWatcher] All watchers stopped')
+}
+
+/**
+ * Get status of all remote watchers
+ */
+export function getRemoteWatcherStatus(): Array<{
+  projectId: string
+  projectPath: string
+  serverId: string
+  pollInterval: number
+  lastPollAt: number
+  lastChangeAt: number
+  errorCount: number
+  watchedChanges: number
+}> {
+  return Array.from(watchedProjects.values()).map(state => ({
+    projectId: state.projectId,
+    projectPath: state.projectPath,
+    serverId: state.serverId,
+    pollInterval: state.pollInterval,
+    lastPollAt: state.lastPollAt,
+    lastChangeAt: state.lastChangeAt,
+    errorCount: state.errorCount,
+    watchedChanges: state.mtimeCache.size,
+  }))
+}
+
+/**
+ * Schedule the next poll
+ */
+function scheduleNextPoll(state: WatchedProject): void {
+  if (state.timer) {
+    clearTimeout(state.timer)
+  }
+
+  state.timer = setTimeout(async () => {
+    await pollRemoteChanges(state)
+    scheduleNextPoll(state)
+  }, state.pollInterval)
+}
+
+/**
+ * Adjust poll interval based on activity
+ */
+function adjustPollInterval(state: WatchedProject, changesDetected: boolean): void {
+  const now = Date.now()
+
+  if (changesDetected) {
+    // Enter burst mode
+    state.pollInterval = POLL_INTERVAL_MIN
+    state.lastChangeAt = now
+  } else if (state.lastChangeAt > 0 && now - state.lastChangeAt < BURST_MODE_DURATION) {
+    // Stay in burst mode
+    state.pollInterval = POLL_INTERVAL_MIN
+  } else if (state.lastChangeAt > 0 && now - state.lastChangeAt > IDLE_THRESHOLD) {
+    // Enter idle mode
+    state.pollInterval = POLL_INTERVAL_MAX
+  } else {
+    // Normal mode
+    state.pollInterval = POLL_INTERVAL_DEFAULT
+  }
+}
+
+/**
+ * Main polling logic - check remote tasks.md files for changes
+ */
+async function pollRemoteChanges(state: WatchedProject): Promise<void> {
+  const plugin = await loadRemotePlugin()
+  if (!plugin) return
+
+  state.lastPollAt = Date.now()
+
+  try {
+    // Get SSH server connection
+    const server = await plugin.getRemoteServerById(state.serverId)
+    if (!server) {
+      throw new Error(`Server not found: ${state.serverId}`)
+    }
+
+    let changesDetected = false
+
+    // Get SFTP for stat operations
+    const sftp = await plugin.getSFTP(server)
+
+    // 1. Poll MoAI SPECs directory (.moai/specs/)
+    const moaiSpecsDir = join(state.projectPath, '.moai/specs')
+    try {
+      const moaiListing = await plugin.listDirectory(server, moaiSpecsDir)
+
+      for (const entry of moaiListing.entries) {
+        if (entry.type !== 'directory' && entry.type !== 'd' && entry.type !== 'Directory') continue
+        if (!entry.name.match(/^SPEC-[A-Z]+-\d+$/)) continue
+
+        const specId = entry.name
+        const planPath = join(moaiSpecsDir, specId, 'plan.md')
+        const cacheKey = `moai:${specId}`
+
+        try {
+          const stat = await sftp.stat(planPath)
+          const currentMtime = stat.mtime * 1000
+
+          const cachedMtime = state.mtimeCache.get(cacheKey)
+
+          if (cachedMtime === undefined) {
+            state.mtimeCache.set(cacheKey, currentMtime)
+          } else if (currentMtime !== cachedMtime) {
+            console.log(`[RemoteWatcher] Detected MoAI SPEC change in ${specId}`)
+            changesDetected = true
+            state.mtimeCache.set(cacheKey, currentMtime)
+
+            // Broadcast WebSocket event for SPEC update
+            const event: WSEvent = {
+              type: 'spec:updated' as const,
+              payload: {
+                specId,
+                projectPath: state.projectPath,
+              },
+              timestamp: Date.now(),
+            }
+            broadcast(event)
+          }
+        } catch {
+          // plan.md doesn't exist, continue
+        }
+      }
+    } catch {
+      // .moai/specs/ might not exist
+    }
+
+    // 2. Poll OpenSpec changes directory (openspec/changes/)
+    const changesDir = join(state.projectPath, 'openspec/changes')
+    let listing: { entries: Array<{ name: string; type: string }> }
+
+    try {
+      listing = await plugin.listDirectory(server, changesDir)
+    } catch {
+      // Directory might not exist - adjust interval and return
+      adjustPollInterval(state, changesDetected)
+      return
+    }
+
+    for (const entry of listing.entries) {
+      if (entry.type !== 'directory' || entry.name === 'archive') continue
+
+      const changeId = entry.name
+      const tasksPath = join(changesDir, changeId, 'tasks.md')
+
+      try {
+        // Check file mtime using SFTP stat
+        let currentMtime: number
+
+        try {
+          const stat = await sftp.stat(tasksPath)
+          currentMtime = stat.mtime * 1000 // Convert to ms
+        } catch {
+          continue // File doesn't exist
+        }
+
+        const cachedMtime = state.mtimeCache.get(changeId)
+
+        if (cachedMtime === undefined) {
+          // First time seeing this file - just cache it
+          state.mtimeCache.set(changeId, currentMtime)
+        } else if (currentMtime !== cachedMtime) {
+          // File changed!
+          console.log(`[RemoteWatcher] Detected change in ${changeId}`)
+          changesDetected = true
+
+          // Update cache
+          state.mtimeCache.set(changeId, currentMtime)
+
+          // Sync to database
+          try {
+            const result = await syncRemoteChangeTasksForProject(
+              changeId,
+              state.projectPath,
+              server,
+              state.projectId
+            )
+
+            console.log(`[RemoteWatcher] Synced ${changeId}: created=${result.tasksCreated}, updated=${result.tasksUpdated}`)
+
+            // Broadcast WebSocket event
+            const event: WSEvent = {
+              type: 'change:synced' as const,
+              payload: {
+                changeId,
+                projectPath: state.projectPath,
+                tasksCreated: result.tasksCreated,
+                tasksUpdated: result.tasksUpdated,
+                tasksArchived: 0,
+              },
+              timestamp: Date.now(),
+            }
+
+            broadcast(event)
+          } catch (syncError) {
+            console.error(`[RemoteWatcher] Sync error for ${changeId}:`, syncError)
+          }
+        }
+      } catch (fileError) {
+        // Individual file error - continue with others
+        // Don't log to avoid spam for missing files
+      }
+    }
+
+    // Reset error count on successful poll
+    state.errorCount = 0
+
+    // Adjust interval based on activity
+    adjustPollInterval(state, changesDetected)
+
+  } catch (error) {
+    state.errorCount++
+    // Exponential backoff with ceiling at 5 minutes
+    const backoff = Math.min(5000 * Math.pow(2, state.errorCount), 300000)
+
+    console.error(
+      `[RemoteWatcher] Poll error for ${state.projectId} (${state.errorCount} consecutive errors):`,
+      (error as any).message || error
+    )
+    console.log(`[RemoteWatcher] Next poll in ${backoff}ms`)
+
+    // Stop watcher after 5 consecutive failures
+    if (state.errorCount >= 5) {
+      console.error(
+        `[RemoteWatcher] Too many consecutive failures (${state.errorCount}), stopping watcher for ${state.projectId}`
+      )
+      stopRemoteWatcher(state.projectId)
+
+      // Broadcast error to UI
+      const event: WSEvent = {
+        type: 'watcher:error' as const,
+        payload: {
+          projectId: state.projectId,
+          error: 'Remote watcher stopped due to connection failures',
+        },
+        timestamp: Date.now(),
+      }
+      broadcast(event)
+      return
+    }
+
+    state.pollInterval = backoff
+  }
+}