@fermindi/pwn-cli 0.1.0

package/src/services/batch-service.js

@@ -0,0 +1,849 @@
+/**
+ * PWN Batch Service
+ *
+ * Autonomous batch task execution with quality gates,
+ * checkpointing, and signal handling.
+ */
+
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getState, updateState, hasWorkspace } from '../core/state.js';
+import * as notifications from './notification-service.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Default batch configuration
+ */
+const DEFAULT_CONFIG = {
+  max_tasks: 5,
+  max_duration_hours: 4,
+  quality_gates: ['typecheck', 'lint', 'test'],
+  skip_gates: [],
+  auto_commit: true,
+  auto_push: false,
+  create_pr: false,
+  branch_format: 'feature/{id}-{slug}',
+  commit_format: 'conventional',
+  selection_strategy: 'priority', // priority, effort, due_date
+  notify_on_complete: true,
+  notify_on_error: true
+};
+
+/**
+ * Quality gate commands mapping
+ */
+const GATE_COMMANDS = {
+  typecheck: ['npm run typecheck', 'npx tsc --noEmit'],
+  lint: ['npm run lint', 'npx eslint .'],
+  test: ['npm run test', 'npm test', 'npx vitest run', 'npx jest'],
+  build: ['npm run build'],
+  security: ['npm run security', 'npm audit']
+};
+
+/**
+ * Load batch configuration from state.json
+ * @param {string} cwd - Working directory
+ * @returns {object} Batch configuration
+ */
+export function loadConfig(cwd = process.cwd()) {
+  const state = getState(cwd);
+
+  if (state?.batch_config) {
+    return { ...DEFAULT_CONFIG, ...state.batch_config };
+  }
+
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Save batch configuration to state.json
+ * @param {object} config - Configuration to save
+ * @param {string} cwd - Working directory
+ */
+export function saveConfig(config, cwd = process.cwd()) {
+  updateState({ batch_config: config }, cwd);
+}
+
+/**
+ * Get current batch state
+ * @param {string} cwd - Working directory
+ * @returns {object|null} Batch state or null if no batch running
+ */
+export function getBatchState(cwd = process.cwd()) {
+  const state = getState(cwd);
+  return state?.batch_state || null;
+}
+
+/**
+ * Update batch state
+ * @param {object} updates - State updates
+ * @param {string} cwd - Working directory
+ */
+export function updateBatchState(updates, cwd = process.cwd()) {
+  const currentBatchState = getBatchState(cwd) || {};
+  updateState({
+    batch_state: {
+      ...currentBatchState,
+      ...updates,
+      last_updated: new Date().toISOString()
+    }
+  }, cwd);
+}
+
+/**
+ * Clear batch state (after completion)
+ * @param {string} cwd - Working directory
+ */
+export function clearBatchState(cwd = process.cwd()) {
+  const state = getState(cwd);
+  if (state) {
+    const { batch_state, ...rest } = state;
+    writeFileSync(
+      join(cwd, '.ai', 'state.json'),
+      JSON.stringify({ ...rest, last_updated: new Date().toISOString() }, null, 2)
+    );
+  }
+}
+
+/**
+ * Parse tasks from active.md
+ * @param {string} cwd - Working directory
+ * @returns {Array<object>} Array of tasks
+ */
+export function parseActiveTasks(cwd = process.cwd()) {
+  const activePath = join(cwd, '.ai', 'tasks', 'active.md');
+
+  if (!existsSync(activePath)) {
+    return [];
+  }
+
+  const content = readFileSync(activePath, 'utf8');
+  return parseTasksFromMarkdown(content);
+}
+
+/**
+ * Parse tasks from backlog.md
+ * @param {string} cwd - Working directory
+ * @returns {Array<object>} Array of tasks
+ */
+export function parseBacklogTasks(cwd = process.cwd()) {
+  const backlogPath = join(cwd, '.ai', 'tasks', 'backlog.md');
+
+  if (!existsSync(backlogPath)) {
+    return [];
+  }
+
+  const content = readFileSync(backlogPath, 'utf8');
+  return parseBacklogFromMarkdown(content);
+}
+
+/**
+ * Parse task items from markdown checkbox format
+ * @param {string} content - Markdown content
+ * @returns {Array<object>} Parsed tasks
+ */
+function parseTasksFromMarkdown(content) {
+  const tasks = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Match: - [ ] US-001: Task title or - [x] US-001: Task title
+    const match = line.match(/^- \[([ x])\]\s*([A-Z]+-\d+):\s*(.+)$/i);
+
+    if (match) {
+      const task = {
+        id: match[2],
+        title: match[3].trim(),
+        completed: match[1].toLowerCase() === 'x',
+        line: i + 1,
+        raw: line
+      };
+
+      // Look for metadata in following lines (indented)
+      let j = i + 1;
+      while (j < lines.length && lines[j].match(/^\s{2,}-?\s*/)) {
+        const metaLine = lines[j].trim();
+
+        if (metaLine.startsWith('- Assignee:') || metaLine.startsWith('Assignee:')) {
+          task.assignee = metaLine.split(':')[1]?.trim();
+        } else if (metaLine.startsWith('- Priority:') || metaLine.startsWith('Priority:')) {
+          task.priority = metaLine.split(':')[1]?.trim().toLowerCase();
+        } else if (metaLine.startsWith('- Blocked by:') || metaLine.startsWith('Blocked by:')) {
+          task.blockedBy = metaLine.split(':')[1]?.trim();
+        } else if (metaLine.startsWith('- Notes:') || metaLine.startsWith('Notes:')) {
+          task.notes = metaLine.split(':').slice(1).join(':').trim();
+        }
+        j++;
+      }
+
+      tasks.push(task);
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Parse backlog items from markdown header format
+ * @param {string} content - Markdown content
+ * @returns {Array<object>} Parsed tasks
+ */
+function parseBacklogFromMarkdown(content) {
+  const tasks = [];
+  const lines = content.split('\n');
+
+  let currentSection = '';
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Track section headers (## High Priority, ## Medium Priority, etc.)
+    const sectionMatch = line.match(/^##\s+(.+)/);
+    if (sectionMatch) {
+      const section = sectionMatch[1].toLowerCase();
+      if (section.includes('high')) currentSection = 'high';
+      else if (section.includes('medium')) currentSection = 'medium';
+      else if (section.includes('low')) currentSection = 'low';
+      else if (section.includes('roadmap')) currentSection = 'roadmap';
+      continue;
+    }
+
+    // Match: ### US-001: Task title
+    const taskMatch = line.match(/^###\s*([A-Z]+-\d+):\s*(.+)$/i);
+
+    if (taskMatch) {
+      const task = {
+        id: taskMatch[1],
+        title: taskMatch[2].trim(),
+        section: currentSection,
+        priority: currentSection === 'high' ? 'high' :
+                  currentSection === 'medium' ? 'medium' : 'low',
+        line: i + 1
+      };
+
+      // Look ahead for metadata lines
+      let j = i + 1;
+      while (j < lines.length) {
+        const metaLine = lines[j];
+
+        // Stop at next task or section
+        if (metaLine.match(/^###?\s/)) break;
+
+        // Parse metadata (may have leading whitespace)
+        // Format: **Key:** Value (note: colon inside the bold)
+        const metaMatch = metaLine.match(/^\s*\*\*([^:*]+):\*\*\s*(.+)/);
+        if (metaMatch) {
+          const key = metaMatch[1].toLowerCase().trim();
+          const value = metaMatch[2].trim();
+
+          if (key === 'type') task.type = value.toLowerCase();
+          else if (key === 'priority') task.priority = value.toLowerCase();
+          else if (key === 'effort') task.effort = value.toUpperCase();
+          else if (key === 'description') task.description = value;
+          else if (key === 'dependencies') task.dependencies = value;
+        }
+        j++;
+      }
+
+      tasks.push(task);
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Select next task to execute based on strategy
+ * @param {string} cwd - Working directory
+ * @param {object} options - Selection options
+ * @returns {object|null} Selected task or null
+ */
+export function selectNextTask(cwd = process.cwd(), options = {}) {
+  const config = loadConfig(cwd);
+  const strategy = options.strategy || config.selection_strategy;
+  const priorityFilter = options.priority;
+
+  // First check active tasks for incomplete ones
+  const activeTasks = parseActiveTasks(cwd);
+  const pendingActive = activeTasks.filter(t => !t.completed && !t.blockedBy);
+
+  if (pendingActive.length > 0) {
+    return pendingActive[0];
+  }
+
+  // Then check backlog
+  let backlogTasks = parseBacklogTasks(cwd);
+
+  // Filter by priority if specified
+  if (priorityFilter) {
+    backlogTasks = backlogTasks.filter(t => t.priority === priorityFilter);
+  }
+
+  // Filter out blocked tasks
+  backlogTasks = backlogTasks.filter(t => !t.dependencies || t.dependencies === 'None');
+
+  if (backlogTasks.length === 0) {
+    return null;
+  }
+
+  // Sort based on strategy
+  switch (strategy) {
+    case 'effort':
+      // Sort by effort (smallest first)
+      const effortOrder = { 'XS': 1, 'S': 2, 'M': 3, 'L': 4, 'XL': 5 };
+      backlogTasks.sort((a, b) => {
+        const aEffort = effortOrder[a.effort] || 3;
+        const bEffort = effortOrder[b.effort] || 3;
+        return aEffort - bEffort;
+      });
+      break;
+
+    case 'priority':
+    default:
+      // Sort by priority (highest first), then by position
+      const priorityOrder = { 'high': 1, 'medium': 2, 'low': 3 };
+      backlogTasks.sort((a, b) => {
+        const aPriority = priorityOrder[a.priority] || 2;
+        const bPriority = priorityOrder[b.priority] || 2;
+        if (aPriority !== bPriority) return aPriority - bPriority;
+        return a.line - b.line;
+      });
+      break;
+  }
+
+  return backlogTasks[0];
+}
+
+/**
+ * Run a single quality gate
+ * @param {string} gate - Gate name (typecheck, lint, test, build, security)
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, output?: string, error?: string}>}
+ */
+export async function runQualityGate(gate, cwd = process.cwd()) {
+  const commands = GATE_COMMANDS[gate];
+
+  if (!commands) {
+    return { success: false, error: `Unknown gate: ${gate}` };
+  }
+
+  // Try each command variant
+  for (const command of commands) {
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd,
+        timeout: 300000, // 5 minutes
+        maxBuffer: 10 * 1024 * 1024 // 10MB
+      });
+
+      return {
+        success: true,
+        output: stdout + (stderr ? '\n' + stderr : ''),
+        command
+      };
+    } catch (error) {
+      // If command not found, try next variant
+      if (error.message?.includes('not found') ||
+          error.message?.includes('ENOENT') ||
+          error.message?.includes('missing script')) {
+        continue;
+      }
+
+      // Command found but failed
+      return {
+        success: false,
+        error: error.message,
+        output: error.stdout,
+        stderr: error.stderr,
+        command
+      };
+    }
+  }
+
+  // No command variant worked
+  return {
+    success: true, // Skip if no command available
+    skipped: true,
+    output: `No ${gate} command available, skipping`
+  };
+}
+
+/**
+ * Run all configured quality gates
+ * @param {string} cwd - Working directory
+ * @param {object} options - Gate options
+ * @returns {Promise<{success: boolean, results: object}>}
+ */
+export async function runQualityGates(cwd = process.cwd(), options = {}) {
+  const config = loadConfig(cwd);
+  const gates = options.gates || config.quality_gates;
+  const skipGates = options.skip || config.skip_gates;
+
+  const results = {};
+  let allPassed = true;
+
+  for (const gate of gates) {
+    if (skipGates.includes(gate)) {
+      results[gate] = { success: true, skipped: true, reason: 'Configured to skip' };
+      continue;
+    }
+
+    const result = await runQualityGate(gate, cwd);
+    results[gate] = result;
+
+    if (!result.success && !result.skipped) {
+      allPassed = false;
+      if (options.failFast !== false) {
+        break; // Stop on first failure
+      }
+    }
+  }
+
+  return { success: allPassed, results };
+}
+
+/**
+ * Create a slug from task title
+ * @param {string} title - Task title
+ * @returns {string} URL-safe slug
+ */
+function createSlug(title) {
+  return title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')
+    .substring(0, 50);
+}
+
+/**
+ * Create feature branch for task
+ * @param {object} task - Task object
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, branch?: string, error?: string}>}
+ */
+export async function createFeatureBranch(task, cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const slug = createSlug(task.title);
+  const branch = config.branch_format
+    .replace('{id}', task.id.toLowerCase())
+    .replace('{slug}', slug);
+
+  try {
+    // Check if branch exists
+    try {
+      await execAsync(`git rev-parse --verify ${branch}`, { cwd });
+      // Branch exists, switch to it
+      await execAsync(`git checkout ${branch}`, { cwd });
+    } catch {
+      // Branch doesn't exist, create it
+      await execAsync(`git checkout -b ${branch}`, { cwd });
+    }
+
+    return { success: true, branch };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Commit task changes
+ * @param {object} task - Task object
+ * @param {object} options - Commit options
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function commitTask(task, options = {}, cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+
+  try {
+    // Stage all changes
+    await execAsync('git add .', { cwd });
+
+    // Check if there are changes to commit
+    try {
+      await execAsync('git diff --cached --quiet', { cwd });
+      // No changes
+      return { success: true, noChanges: true };
+    } catch {
+      // There are changes, continue with commit
+    }
+
+    // Build commit message
+    const type = task.id.startsWith('BUG') ? 'fix' :
+                 task.id.startsWith('DEV') ? 'refactor' :
+                 task.id.startsWith('DOCS') ? 'docs' :
+                 task.id.startsWith('SPIKE') ? 'chore' : 'feat';
+
+    const scope = options.scope || '';
+    const scopePart = scope ? `(${scope})` : '';
+    const message = options.message || task.title;
+
+    const commitMessage = config.commit_format === 'conventional'
+      ? `${type}${scopePart}: ${task.id} - ${message}\n\nFixes: ${task.id}\n\nCo-Authored-By: Claude <noreply@anthropic.com>`
+      : `${task.id}: ${message}`;
+
+    // Commit using heredoc for proper formatting
+    await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd });
+
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Push changes to remote
+ * @param {string} branch - Branch name
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, error?: string}>}
+ */
+export async function pushToRemote(branch, cwd = process.cwd()) {
+  try {
+    await execAsync(`git push -u origin ${branch}`, { cwd });
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Mark task as complete in active.md
+ * @param {string} taskId - Task ID
+ * @param {string} cwd - Working directory
+ * @returns {boolean} Success
+ */
+export function markTaskComplete(taskId, cwd = process.cwd()) {
+  const activePath = join(cwd, '.ai', 'tasks', 'active.md');
+
+  if (!existsSync(activePath)) {
+    return false;
+  }
+
+  const content = readFileSync(activePath, 'utf8');
+  const date = new Date().toISOString().split('T')[0];
+
+  // Replace [ ] with [x] for the task
+  const updated = content.replace(
+    new RegExp(`^(- \\[) \\](\\s*${taskId}:.*)$`, 'mi'),
+    `$1x]$2 (${date})`
+  );
+
+  if (updated !== content) {
+    writeFileSync(activePath, updated);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Add task to active.md from backlog
+ * @param {object} task - Task object
+ * @param {string} cwd - Working directory
+ * @returns {boolean} Success
+ */
+export function addToActive(task, cwd = process.cwd()) {
+  const activePath = join(cwd, '.ai', 'tasks', 'active.md');
+
+  if (!existsSync(activePath)) {
+    return false;
+  }
+
+  const content = readFileSync(activePath, 'utf8');
+
+  // Find the "Today's Focus" or "Current Sprint" section and add after
+  const newTask = `- [ ] ${task.id}: ${task.title}\n  - Priority: ${task.priority || 'medium'}\n`;
+
+  // Add before "## Notes" or at end
+  const notesIndex = content.indexOf('## Notes');
+  let updated;
+
+  if (notesIndex !== -1) {
+    updated = content.slice(0, notesIndex) + newTask + '\n' + content.slice(notesIndex);
+  } else {
+    updated = content + '\n' + newTask;
+  }
+
+  writeFileSync(activePath, updated);
+  return true;
+}
+
+/**
+ * Pause batch execution
+ * @param {string} reason - Pause reason
+ * @param {string} cwd - Working directory
+ */
+export function pauseBatch(reason, cwd = process.cwd()) {
+  updateBatchState({
+    paused_at: new Date().toISOString(),
+    pause_reason: reason,
+    status: 'paused'
+  }, cwd);
+}
+
+/**
+ * Get batch status summary
+ * @param {string} cwd - Working directory
+ * @returns {object} Status summary
+ */
+export function getStatus(cwd = process.cwd()) {
+  if (!hasWorkspace(cwd)) {
+    return { hasWorkspace: false };
+  }
+
+  const config = loadConfig(cwd);
+  const batchState = getBatchState(cwd);
+  const activeTasks = parseActiveTasks(cwd);
+  const backlogTasks = parseBacklogTasks(cwd);
+
+  const pendingActive = activeTasks.filter(t => !t.completed);
+  const completedActive = activeTasks.filter(t => t.completed);
+
+  return {
+    hasWorkspace: true,
+    config,
+    batchState,
+    tasks: {
+      activeTotal: activeTasks.length,
+      activePending: pendingActive.length,
+      activeCompleted: completedActive.length,
+      backlogTotal: backlogTasks.length,
+      backlogHigh: backlogTasks.filter(t => t.priority === 'high').length,
+      backlogMedium: backlogTasks.filter(t => t.priority === 'medium').length,
+      backlogLow: backlogTasks.filter(t => t.priority === 'low').length
+    },
+    isRunning: batchState?.status === 'running',
+    isPaused: batchState?.status === 'paused',
+    currentTask: batchState?.current_task,
+    pauseReason: batchState?.pause_reason
+  };
+}
+
+/**
+ * Execute a single task with full workflow
+ * @param {object} task - Task to execute
+ * @param {object} options - Execution options
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, error?: string, details?: object}>}
+ */
+export async function executeTask(task, options = {}, cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const details = { task: task.id, steps: [] };
+
+  // Update batch state
+  updateBatchState({
+    current_task: task.id,
+    status: 'running',
+    task_started_at: new Date().toISOString()
+  }, cwd);
+
+  // Step 1: Create feature branch (if auto_commit enabled)
+  if (config.auto_commit && !options.skipBranch) {
+    const branchResult = await createFeatureBranch(task, cwd);
+    details.steps.push({ step: 'create_branch', ...branchResult });
+
+    if (!branchResult.success) {
+      return { success: false, error: `Failed to create branch: ${branchResult.error}`, details };
+    }
+    details.branch = branchResult.branch;
+  }
+
+  // Step 2: This is where actual task execution would happen
+  // In batch mode, this is typically done by an AI agent
+  // The batch service just provides the infrastructure
+  details.steps.push({
+    step: 'execute',
+    success: true,
+    note: 'Task execution handled by AI agent'
+  });
+
+  // Step 3: Run quality gates
+  if (!options.skipGates) {
+    const gatesResult = await runQualityGates(cwd, {
+      gates: config.quality_gates,
+      skip: config.skip_gates
+    });
+    details.steps.push({ step: 'quality_gates', ...gatesResult });
+
+    if (!gatesResult.success) {
+      const failedGates = Object.entries(gatesResult.results)
+        .filter(([_, r]) => !r.success && !r.skipped)
+        .map(([name, r]) => `${name}: ${r.error}`);
+
+      pauseBatch(`Quality gates failed: ${failedGates.join(', ')}`, cwd);
+
+      if (config.notify_on_error) {
+        await notifications.notifyError(
+          'Batch Paused',
+          `Quality gates failed for ${task.id}: ${failedGates.join(', ')}`,
+          { cwd }
+        );
+      }
+
+      return {
+        success: false,
+        error: 'Quality gates failed',
+        details,
+        gateFailures: failedGates
+      };
+    }
+  }
+
+  // Step 4: Commit changes
+  if (config.auto_commit && !options.skipCommit) {
+    const commitResult = await commitTask(task, {}, cwd);
+    details.steps.push({ step: 'commit', ...commitResult });
+
+    if (!commitResult.success) {
+      return { success: false, error: `Failed to commit: ${commitResult.error}`, details };
+    }
+
+    // Step 5: Push to remote
+    if (config.auto_push && details.branch) {
+      const pushResult = await pushToRemote(details.branch, cwd);
+      details.steps.push({ step: 'push', ...pushResult });
+
+      if (!pushResult.success) {
+        // Don't fail the task, just log warning
+        details.pushWarning = pushResult.error;
+      }
+    }
+  }
+
+  // Step 6: Mark task complete
+  markTaskComplete(task.id, cwd);
+  details.steps.push({ step: 'mark_complete', success: true });
+
+  // Update batch state
+  const batchState = getBatchState(cwd);
+  const completed = [...(batchState?.completed || []), task.id];
+  const pending = (batchState?.pending || []).filter(id => id !== task.id);
+
+  updateBatchState({
+    completed,
+    pending,
+    current_task: null,
+    last_completed_at: new Date().toISOString()
+  }, cwd);
+
+  // Notify completion
+  if (config.notify_on_complete) {
+    await notifications.notifyTaskComplete(task.id, task.title, { cwd });
+  }
+
+  return { success: true, details };
+}
+
+/**
+ * Start batch execution
+ * @param {object} options - Batch options
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, completed: string[], errors: object[]}>}
+ */
+export async function startBatch(options = {}, cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const count = options.count || config.max_tasks;
+  const dryRun = options.dryRun || false;
+  const priorityFilter = options.priority;
+
+  const completed = [];
+  const errors = [];
+  const startTime = Date.now();
+  const maxDuration = config.max_duration_hours * 60 * 60 * 1000;
+
+  // Initialize batch state
+  updateBatchState({
+    started_at: new Date().toISOString(),
+    status: 'running',
+    completed: [],
+    pending: [],
+    max_tasks: count
+  }, cwd);
+
+  for (let i = 0; i < count; i++) {
+    // Check time limit
+    if (Date.now() - startTime > maxDuration) {
+      pauseBatch('Time limit reached', cwd);
+      break;
+    }
+
+    // Select next task
+    const task = selectNextTask(cwd, { priority: priorityFilter });
+
+    if (!task) {
+      // No more tasks
+      break;
+    }
+
+    if (dryRun) {
+      completed.push({ id: task.id, title: task.title, dryRun: true });
+      continue;
+    }
+
+    // Execute task
+    const result = await executeTask(task, options, cwd);
+
+    if (result.success) {
+      completed.push({ id: task.id, title: task.title });
+    } else {
+      errors.push({ id: task.id, error: result.error, details: result.details });
+
+      // Stop on error unless configured otherwise
+      if (!options.continueOnError) {
+        break;
+      }
+    }
+  }
+
+  // Finalize batch if all tasks completed successfully
+  if (errors.length === 0) {
+    clearBatchState(cwd);
+  }
+
+  return { success: errors.length === 0, completed, errors };
+}
+
+/**
+ * Resume a paused batch
+ * @param {object} options - Resume options
+ * @param {string} cwd - Working directory
+ * @returns {Promise<{success: boolean, message: string}>}
+ */
+export async function resumeBatch(options = {}, cwd = process.cwd()) {
+  const batchState = getBatchState(cwd);
+
+  if (!batchState) {
+    return { success: false, message: 'No batch state found' };
+  }
+
+  if (batchState.status !== 'paused') {
+    return { success: false, message: `Batch is not paused (status: ${batchState.status})` };
+  }
+
+  // Clear pause state
+  updateBatchState({
+    paused_at: null,
+    pause_reason: null,
+    status: 'running'
+  }, cwd);
+
+  // Skip current task if requested
+  if (options.skip && batchState.current_task) {
+    const pending = (batchState.pending || []).filter(id => id !== batchState.current_task);
+    updateBatchState({
+      current_task: null,
+      pending,
+      skipped: [...(batchState.skipped || []), batchState.current_task]
+    }, cwd);
+  }
+
+  // Continue batch
+  return startBatch({
+    ...options,
+    count: batchState.pending?.length || 1
+  }, cwd);
+}