Function loadTaskProgressForNodes

src/stores/project.ts:253–305

(nodes: TreeNode[], phase: 'initial' | 'background')

  }

  async function loadTaskProgressForNodes(nodes: TreeNode[], phase: 'initial' | 'background') {
    if (!projectPath.value || !isElectron()) return
    if (nodes.length === 0) return

    const perfEnabled = isPerfEnabled()
    const perfStart = perfEnabled ? perfNow() : 0
    let attempts = 0
    let successes = 0

    const queue = nodes.filter(node => {
      const key = normalizePath(node.path || '')
      if (!key) return false
      if (taskProgressCache.has(key)) return false
      if (taskProgressPending.has(key)) return false
      taskProgressPending.add(key)
      return true
    })

    const workers = Array.from({ length: TASK_PROGRESS_CONCURRENCY }, async () => {
      while (queue.length > 0) {
        const node = queue.shift()
        if (!node || !node.path) continue
        const tasksPath = `${node.path}/tasks.md`
        attempts += 1
        try {
          const fullPath = `${projectPath.value}/${tasksPath}`
          const result = await window.electronAPI!.readFile(fullPath)
          if (result.success && result.content) {
            const progress = parseTaskProgress(result.content)
            queueTaskProgressUpdate(node, progress)
            successes += 1
          }
        } catch {
          // ignore missing tasks.md
        } finally {
          taskProgressPending.delete(normalizePath(node.path))
        }
      }
    })

    await Promise.all(workers)

    if (perfEnabled) {
      const durationMs = perfNow() - perfStart
      perfLog('tasks.load', {
        phase,
        durationMs: Math.round(durationMs * 1000) / 1000,
        changeCount: nodes.length,
        attempts,
        successes
      })
    }
  }

  function queueTaskProgressLoad(token: number) {
    const activeChanges = changesTree.value.filter(n => n.name !== 'archive')