@sienklogic/plan-build-run 2.0.0

package/dashboard/src/services/phase.service.js

@@ -0,0 +1,167 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readMarkdownFile } from '../repositories/planning.repository.js';
+
+/**
+ * Format a phase directory name into a human-readable title.
+ * Strips the numeric prefix and title-cases each word.
+ *
+ * @param {string} dirName - Directory name like "04-dashboard-landing-page"
+ * @returns {string} Formatted name like "Dashboard Landing Page"
+ */
+function formatPhaseName(dirName) {
+  const parts = dirName.split('-');
+  // Remove the numeric prefix (first element)
+  parts.shift();
+  return parts
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ');
+}
+
+/**
+ * Parse the "Task Results" markdown table from a SUMMARY.md body.
+ * Returns an array of commit objects extracted from the table rows.
+ *
+ * Expected table format (produced by pbr executor):
+ * | Task | Status | Commit | Files | Verify |
+ * |------|--------|--------|-------|--------|
+ * | 05-01-T1: Create phase.service.js | done | 2a52581 | 1 | passed |
+ *
+ * @param {string} rawContent - The markdown body content (after frontmatter)
+ * @returns {Array<{task: string, status: string, hash: string, files: number, verify: string}>}
+ */
+export function parseTaskResultsTable(rawContent) {
+  if (!rawContent) return [];
+
+  // Find the Task Results section. The table may be followed by another section,
+  // a blank line, or EOF. Use a non-greedy match to capture just the table block.
+  const sectionRegex = /## Task Results\s*\n([\s\S]*?)(?=\n##\s|\n\n\n|$)/;
+  const sectionMatch = rawContent.match(sectionRegex);
+  if (!sectionMatch) return [];
+
+  const tableBlock = sectionMatch[1].trim();
+  const lines = tableBlock.split('\n');
+
+  // Need at least header row + separator row + 1 data row = 3 lines
+  if (lines.length < 3) return [];
+
+  // Skip header row (index 0) and separator row (index 1)
+  const dataRows = lines.slice(2);
+  const commits = [];
+
+  for (const row of dataRows) {
+    // Split by pipe, trim, filter out empty strings from leading/trailing pipes
+    const cells = row.split('|').map(c => c.trim()).filter(c => c);
+    if (cells.length < 5) continue;
+
+    const hash = cells[2];
+    // Skip rows where commit is empty, a dash, or not a hex string
+    if (!hash || hash === '-' || hash === '' || !/^[0-9a-f]{5,40}$/i.test(hash)) continue;
+
+    commits.push({
+      task: cells[0],
+      status: cells[1],
+      hash: hash,
+      files: parseInt(cells[3], 10) || 0,
+      verify: cells[4]
+    });
+  }
+
+  return commits;
+}
+
+/**
+ * Get detailed information about a specific phase, including all plans,
+ * their summaries, and verification status.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {string} phaseId - Two-digit phase identifier (e.g., "04")
+ * @returns {Promise<{phaseId: string, phaseName: string, phaseDir: string|null, plans: Array, verification: object|null}>}
+ */
+export async function getPhaseDetail(projectDir, phaseId) {
+  const emptyState = { phaseId, phaseName: 'Unknown', phaseDir: null, plans: [], verification: null };
+  const phasesDir = join(projectDir, '.planning', 'phases');
+
+  let phaseDirEntries;
+  try {
+    phaseDirEntries = await readdir(phasesDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return emptyState;
+    }
+    throw error;
+  }
+
+  // Find the directory matching this phaseId (prefer longest name to handle stale renames)
+  const phaseDir = phaseDirEntries
+    .filter(entry => entry.isDirectory() && entry.name.startsWith(`${phaseId}-`))
+    .sort((a, b) => b.name.length - a.name.length)
+    [0];
+
+  if (!phaseDir) {
+    return emptyState;
+  }
+
+  const phaseName = formatPhaseName(phaseDir.name);
+  const phaseFullPath = join(phasesDir, phaseDir.name);
+
+  // Read files in the phase directory
+  const phaseFiles = await readdir(phaseFullPath);
+
+  // Filter and sort PLAN.md files
+  const planRegex = /^\d{2}-\d{2}-PLAN\.md$/;
+  const planIdRegex = /^(\d{2}-\d{2})-PLAN\.md$/;
+  const planFiles = phaseFiles
+    .filter(f => planRegex.test(f))
+    .sort();
+
+  // Build summary paths and read them in parallel
+  const summaryPaths = planFiles.map(planFile => {
+    const match = planFile.match(planIdRegex);
+    const planId = match[1];
+    return { planId, planFile, summaryPath: join(phaseFullPath, `SUMMARY-${planId}.md`) };
+  });
+
+  const summaryResults = await Promise.allSettled(
+    summaryPaths.map(({ summaryPath }) => readMarkdownFile(summaryPath))
+  );
+
+  // Map results to plan objects
+  const plans = summaryPaths.map(({ planId, planFile }, index) => {
+    const result = summaryResults[index];
+    if (result.status === 'fulfilled') {
+      return {
+        planId,
+        planFile,
+        summary: result.value.frontmatter,
+        content: result.value.html,
+        commits: parseTaskResultsTable(result.value.rawContent)
+      };
+    }
+    if (result.reason && result.reason.code === 'ENOENT') {
+      return { planId, planFile, summary: null, content: null, commits: [] };
+    }
+    // Unexpected error -- re-throw
+    throw result.reason;
+  });
+
+  // Read VERIFICATION.md
+  let verification = null;
+  try {
+    const verDoc = await readMarkdownFile(join(phaseFullPath, 'VERIFICATION.md'));
+    verification = verDoc.frontmatter;
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
+    // ENOENT -> verification stays null
+  }
+
+  return {
+    phaseId,
+    phaseName,
+    phaseDir: phaseDir.name,
+    plans,
+    verification
+  };
+}

package/dashboard/src/services/project.service.js

@@ -0,0 +1,57 @@
+import { join, resolve, relative } from 'node:path';
+import { readMarkdownFile, listPlanningFiles } from '../repositories/planning.repository.js';
+
+/**
+ * Get homepage data for the dashboard.
+ * Reads .planning/README.md if it exists, returns fallback data if not.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<{title: string, projectDir: string, content: string}>}
+ */
+export async function getHomepage(projectDir) {
+  try {
+    const readmePath = join(projectDir, '.planning', 'README.md');
+    const { frontmatter, html } = await readMarkdownFile(readmePath);
+
+    return {
+      title: frontmatter.title || 'PBR Dashboard',
+      projectDir,
+      content: html
+    };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {
+        title: 'Welcome',
+        projectDir,
+        content: '<p>No project README found.</p>'
+      };
+    }
+    throw error;
+  }
+}
+
+/**
+ * Read a specific markdown file from within the .planning/ directory.
+ * Validates that the resolved path stays within .planning/ to prevent
+ * path traversal attacks.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {string} relativePath - Path relative to .planning/ (e.g., 'phases/01/PLAN.md')
+ * @returns {Promise<{frontmatter: object, html: string, rawContent: string}>}
+ * @throws {Error} If path escapes .planning/ or file not found
+ */
+export async function getMarkdownFile(projectDir, relativePath) {
+  const planningDir = resolve(projectDir, '.planning');
+  const filePath = resolve(planningDir, relativePath);
+
+  // Path traversal protection: ensure resolved path is under .planning/
+  const rel = relative(planningDir, filePath);
+  if (rel.startsWith('..') || resolve(filePath) !== filePath && rel.startsWith('..')) {
+    const err = new Error('Path traversal not allowed: path escapes .planning/ directory');
+    err.code = 'PATH_TRAVERSAL';
+    err.status = 403;
+    throw err;
+  }
+
+  return readMarkdownFile(filePath);
+}

package/dashboard/src/services/roadmap.service.js

@@ -0,0 +1,171 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseRoadmapFile } from './dashboard.service.js';
+
+/**
+ * Strip UTF-8 BOM from file content.
+ * Duplicated intentionally -- this service reads raw text, not via the repository layer.
+ *
+ * @param {string} content - Raw file content
+ * @returns {string} Content without BOM
+ */
+function stripBOM(content) {
+  return content.replace(/^\uFEFF/, '');
+}
+
+/**
+ * Count the number of PLAN.md files in a phase directory.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {number} phaseId - Numeric phase ID (e.g., 1, 5, 12)
+ * @returns {Promise<number>} Number of NN-NN-PLAN.md files found
+ */
+async function countPlansForPhase(projectDir, phaseId) {
+  const phaseIdPadded = String(phaseId).padStart(2, '0');
+  const phasesDir = join(projectDir, '.planning', 'phases');
+
+  try {
+    const entries = await readdir(phasesDir, { withFileTypes: true });
+    // When multiple directories match (e.g. stale rename leftover), prefer the longest name
+    const matchingDirs = entries
+      .filter(e => e.isDirectory() && e.name.startsWith(`${phaseIdPadded}-`))
+      .sort((a, b) => b.name.length - a.name.length);
+    const phaseDir = matchingDirs[0];
+
+    if (!phaseDir) return 0;
+
+    const phaseFiles = await readdir(join(phasesDir, phaseDir.name));
+    return phaseFiles.filter(f => /^\d{2}-\d{2}-PLAN\.md$/.test(f)).length;
+  } catch (err) {
+    if (err.code === 'ENOENT') return 0;
+    throw err;
+  }
+}
+
+/**
+ * Extract dependency information from all Phase Details sections in ROADMAP.md.
+ *
+ * @param {string} roadmapContent - Raw ROADMAP.md content
+ * @returns {Map<number, number[]>} Map of phaseId -> array of dependency phase IDs
+ */
+function extractAllDependencies(roadmapContent) {
+  const dependencyMap = new Map();
+
+  // Match Phase Details sections: "### Phase NN: ..." followed by "**Depends on**: ..."
+  const sectionRegex = /### Phase (\d+):[\s\S]*?\*\*Depends on\*\*:\s*([^\n]+)/g;
+  let match;
+
+  while ((match = sectionRegex.exec(roadmapContent)) !== null) {
+    const phaseId = parseInt(match[1], 10);
+    const depText = match[2].trim();
+
+    if (depText.toLowerCase().includes('none')) {
+      dependencyMap.set(phaseId, []);
+      continue;
+    }
+
+    // Extract phase numbers from "Phase 01, Phase 02" format
+    const deps = [];
+    const depMatches = depText.matchAll(/Phase (\d+)/g);
+    for (const dm of depMatches) {
+      deps.push(parseInt(dm[1], 10));
+    }
+    dependencyMap.set(phaseId, deps);
+  }
+
+  return dependencyMap;
+}
+
+/**
+ * Extract milestone information from ROADMAP.md.
+ * Parses explicit "## Milestone:" sections and infers the implicit first milestone
+ * from the roadmap title (phases before the first explicit milestone).
+ *
+ * @param {string} roadmapContent - Raw ROADMAP.md content (newlines normalized)
+ * @returns {Array<{name: string, goal: string, startPhase: number, endPhase: number}>}
+ */
+function extractMilestones(roadmapContent) {
+  const milestones = [];
+
+  // Get project title from H1: "# Roadmap: PBR Dashboard"
+  const titleMatch = roadmapContent.match(/^# Roadmap:\s*(.+)$/m);
+  const projectTitle = titleMatch ? titleMatch[1].trim() : 'Project';
+
+  // Parse explicit milestones: "## Milestone: Name\n\n**Goal:** ...\n**Phases:** N - M"
+  const milestoneRegex = /## Milestone:\s*(.+)\n\n\*\*Goal:\*\*\s*(.+)\n\*\*Phases:\*\*\s*(\d+)\s*-\s*(\d+)/g;
+  const explicit = [];
+  for (const match of roadmapContent.matchAll(milestoneRegex)) {
+    explicit.push({
+      name: match[1].trim(),
+      goal: match[2].trim(),
+      startPhase: parseInt(match[3], 10),
+      endPhase: parseInt(match[4], 10)
+    });
+  }
+
+  // Sort explicit milestones by start phase
+  explicit.sort((a, b) => a.startPhase - b.startPhase);
+
+  // Infer implicit first milestone (phases before first explicit milestone)
+  if (explicit.length > 0) {
+    const firstStart = explicit[0].startPhase;
+    if (firstStart > 1) {
+      milestones.push({
+        name: projectTitle,
+        goal: '',
+        startPhase: 1,
+        endPhase: firstStart - 1
+      });
+    }
+  } else {
+    // No explicit milestones — all phases belong to the project
+    milestones.push({
+      name: projectTitle,
+      goal: '',
+      startPhase: 1,
+      endPhase: 9999
+    });
+  }
+
+  milestones.push(...explicit);
+  return milestones;
+}
+
+/**
+ * Get enhanced roadmap data with plan counts, dependencies, and milestones.
+ * Combines parseRoadmapFile with raw ROADMAP.md reading for dependency
+ * extraction, milestone parsing, and directory scanning for plan counts.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<{phases: Array, milestones: Array}>}
+ */
+export async function getRoadmapData(projectDir) {
+  const { phases: basePhases } = await parseRoadmapFile(projectDir);
+
+  if (basePhases.length === 0) {
+    return { phases: [], milestones: [] };
+  }
+
+  // Read raw ROADMAP.md for dependencies and milestones
+  let dependencyMap = new Map();
+  let milestones = [];
+  try {
+    const roadmapPath = join(projectDir, '.planning', 'ROADMAP.md');
+    const rawContent = stripBOM(await readFile(roadmapPath, 'utf-8')).replace(/\r\n/g, '\n');
+    dependencyMap = extractAllDependencies(rawContent);
+    milestones = extractMilestones(rawContent);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  // Enhance each phase with plan count and dependencies in parallel
+  const enhancedPhases = await Promise.all(
+    basePhases.map(async (phase) => {
+      const planCount = await countPlansForPhase(projectDir, phase.id);
+      const dependencies = dependencyMap.get(phase.id) || [];
+      return { ...phase, planCount, dependencies };
+    })
+  );
+
+  return { phases: enhancedPhases, milestones };
+}

package/dashboard/src/services/sse.service.js

@@ -0,0 +1,58 @@
+/**
+ * SSE (Server-Sent Events) service.
+ * Manages a Set of active client response objects and provides
+ * broadcast functionality to send events to all connected browsers.
+ */
+
+/** @type {Set<import('http').ServerResponse>} */
+const clients = new Set();
+
+/**
+ * Register a client response object for SSE broadcasting.
+ * @param {import('http').ServerResponse} res
+ */
+export function addClient(res) {
+  clients.add(res);
+}
+
+/**
+ * Remove a client response object (called on disconnect).
+ * @param {import('http').ServerResponse} res
+ */
+export function removeClient(res) {
+  clients.delete(res);
+}
+
+/**
+ * Broadcast an SSE event to all connected clients.
+ * Clients that throw on write are automatically removed.
+ * @param {string} eventType - SSE event name (e.g. 'file-change')
+ * @param {object} data - Payload to JSON-serialize in the data field
+ */
+export function broadcast(eventType, data) {
+  const id = Date.now();
+  const message = `event: ${eventType}\ndata: ${JSON.stringify(data)}\nid: ${id}\n\n`;
+
+  for (const client of clients) {
+    try {
+      client.write(message);
+    } catch {
+      clients.delete(client);
+    }
+  }
+}
+
+/**
+ * Return the number of currently connected clients.
+ * @returns {number}
+ */
+export function getClientCount() {
+  return clients.size;
+}
+
+/**
+ * Remove all clients. Used in tests to reset state between test cases.
+ */
+export function clearClients() {
+  clients.clear();
+}

package/dashboard/src/services/todo.service.js

@@ -0,0 +1,254 @@
+import { readdir, readFile, writeFile, rename, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+import { readMarkdownFile } from '../repositories/planning.repository.js';
+
+const PRIORITY_ORDER = { P0: 0, P1: 1, P2: 2, PX: 3 };
+
+class WriteQueue {
+  constructor() {
+    this.tail = Promise.resolve();
+  }
+
+  enqueue(fn) {
+    const task = this.tail.then(fn, fn);
+    this.tail = task.catch(() => {});
+    return task;
+  }
+}
+
+const writeQueue = new WriteQueue();
+
+function titleToSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 50);
+}
+
+async function getNextTodoId(projectDir) {
+  const pendingDir = join(projectDir, '.planning', 'todos', 'pending');
+  const doneDir = join(projectDir, '.planning', 'todos', 'done');
+
+  let highestId = 0;
+
+  for (const dir of [pendingDir, doneDir]) {
+    try {
+      const files = await readdir(dir);
+      for (const filename of files) {
+        const match = filename.match(/^(\d{3})-/);
+        if (match) {
+          const id = parseInt(match[1], 10);
+          if (id > highestId) highestId = id;
+        }
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+
+  return String(highestId + 1).padStart(3, '0');
+}
+
+/**
+ * Sort todos by priority (P0 first) then alphabetically by title.
+ * Unknown priorities sort after PX.
+ * @param {Array} todos - Array of todo objects with priority and title fields
+ * @returns {Array} Sorted array (mutates and returns the input)
+ */
+function sortTodosByPriority(todos) {
+  return todos.sort((a, b) => {
+    const aPriority = PRIORITY_ORDER[a.priority] ?? 99;
+    const bPriority = PRIORITY_ORDER[b.priority] ?? 99;
+    const priorityDiff = aPriority - bPriority;
+    if (priorityDiff !== 0) return priorityDiff;
+    return a.title.localeCompare(b.title);
+  });
+}
+
+/**
+ * List all pending todos from .planning/todos/pending/ directory.
+ * Reads each markdown file, parses frontmatter, filters invalid entries,
+ * and returns sorted by priority then title.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<Array<{id: string, title: string, priority: string, phase: string, status: string, created: string, filename: string}>>}
+ */
+export async function listPendingTodos(projectDir) {
+  const pendingDir = join(projectDir, '.planning', 'todos', 'pending');
+
+  let entries;
+  try {
+    entries = await readdir(pendingDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+
+  // Filter for .md files and extract ID from filename prefix
+  const mdFiles = entries
+    .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+    .map(entry => ({
+      filename: entry.name,
+      filePath: join(pendingDir, entry.name),
+      fileId: entry.name.match(/^(\d{3})-/)?.[1] || null
+    }))
+    .filter(f => f.fileId !== null);
+
+  // Read all todo files in parallel with partial failure tolerance
+  const results = await Promise.allSettled(
+    mdFiles.map(f => readMarkdownFile(f.filePath))
+  );
+
+  const todos = [];
+  for (let i = 0; i < results.length; i++) {
+    if (results[i].status !== 'fulfilled') continue;
+
+    const { frontmatter } = results[i].value;
+    const { filename, fileId } = mdFiles[i];
+
+    // Skip todos missing required frontmatter fields
+    const title = frontmatter.title;
+    const priority = frontmatter.priority;
+    if (!title || !priority) continue;
+
+    todos.push({
+      id: frontmatter.id || fileId,
+      title,
+      priority,
+      phase: frontmatter.phase || '',
+      status: frontmatter.status || 'pending',
+      created: frontmatter.created ? String(frontmatter.created) : '',
+      filename
+    });
+  }
+
+  return sortTodosByPriority(todos);
+}
+
+/**
+ * Get a single todo by ID with full markdown content.
+ * Searches .planning/todos/pending/ for a file whose name starts with the given ID.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {string} todoId - Three-digit todo ID (e.g., "001", "042")
+ * @returns {Promise<{id: string, title: string, priority: string, phase: string, status: string, created: string, html: string, filename: string}>}
+ * @throws {Error} With status 404 if no todo matches the given ID
+ */
+export async function getTodoDetail(projectDir, todoId) {
+  const pendingDir = join(projectDir, '.planning', 'todos', 'pending');
+
+  let entries;
+  try {
+    entries = await readdir(pendingDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      const notFound = new Error(`Todo ${todoId} not found`);
+      notFound.status = 404;
+      throw notFound;
+    }
+    throw err;
+  }
+
+  // Find the file whose name starts with the todoId prefix
+  const matchingFile = entries.find(name =>
+    name.startsWith(`${todoId}-`) && name.endsWith('.md')
+  );
+
+  if (!matchingFile) {
+    const notFound = new Error(`Todo ${todoId} not found`);
+    notFound.status = 404;
+    throw notFound;
+  }
+
+  const filePath = join(pendingDir, matchingFile);
+  const { frontmatter, html } = await readMarkdownFile(filePath);
+
+  return {
+    id: frontmatter.id || todoId,
+    title: frontmatter.title || 'Untitled',
+    priority: frontmatter.priority || 'PX',
+    phase: frontmatter.phase || '',
+    status: frontmatter.status || 'pending',
+    created: frontmatter.created ? String(frontmatter.created) : '',
+    html,
+    filename: matchingFile
+  };
+}
+
+export async function createTodo(projectDir, todoData) {
+  const { title, priority, description } = todoData;
+  const phase = todoData.phase || '';
+
+  if (!title || !priority || !description) {
+    const err = new Error('Missing required fields: title, priority, and description are required');
+    err.status = 400;
+    throw err;
+  }
+
+  return writeQueue.enqueue(async () => {
+    const todoId = await getNextTodoId(projectDir);
+    const slug = titleToSlug(title);
+    const filename = `${todoId}-${slug}.md`;
+    const pendingDir = join(projectDir, '.planning', 'todos', 'pending');
+
+    await mkdir(pendingDir, { recursive: true });
+
+    const frontmatter = {
+      id: todoId,
+      title,
+      priority,
+      phase,
+      status: 'pending',
+      created: new Date().toISOString().split('T')[0]
+    };
+
+    const fileContent = matter.stringify(description, frontmatter);
+    const filePath = join(pendingDir, filename);
+    await writeFile(filePath, fileContent, 'utf-8');
+
+    return todoId;
+  });
+}
+
+export async function completeTodo(projectDir, todoId) {
+  return writeQueue.enqueue(async () => {
+    const pendingDir = join(projectDir, '.planning', 'todos', 'pending');
+    const doneDir = join(projectDir, '.planning', 'todos', 'done');
+
+    let entries;
+    try {
+      entries = await readdir(pendingDir);
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        const notFound = new Error(`Todo ${todoId} not found`);
+        notFound.status = 404;
+        throw notFound;
+      }
+      throw err;
+    }
+
+    const matchingFile = entries.find(name =>
+      name.startsWith(`${todoId}-`) && name.endsWith('.md')
+    );
+
+    if (!matchingFile) {
+      const notFound = new Error(`Todo ${todoId} not found`);
+      notFound.status = 404;
+      throw notFound;
+    }
+
+    const pendingPath = join(pendingDir, matchingFile);
+    const raw = await readFile(pendingPath, 'utf-8');
+    const parsed = matter(raw, { engines: { javascript: false } });
+
+    parsed.data.status = 'done';
+    const updatedContent = matter.stringify(parsed.content, parsed.data);
+    await writeFile(pendingPath, updatedContent, 'utf-8');
+
+    await mkdir(doneDir, { recursive: true });
+    const donePath = join(doneDir, matchingFile);
+    await rename(pendingPath, donePath);
+  });
+}