From 590d4b4114edee407a8ae41d1b41445f2f855217 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Fri, 15 Aug 2025 16:38:36 +0000
Subject: [PATCH] Refactor: Improve CLI structure and testability

This commit performs a major refactoring of the CLI application to improve its structure, maintainability, and testability.

The monolithic `blackbox-cli.js` file has been broken down into smaller, single-responsibility modules:
- The `batch-call` command logic is now encapsulated in a new `BatchCaller` class (`lib/batch-caller.js`).
- The `watch` command logic has been moved into the `CampaignWatcher` class (`lib/campaign-watcher.js`).
- Common utility functions have been extracted to `lib/utils.js`.

This new structure makes the code more organized, easier to understand, and significantly more testable.

New unit tests have been added for the `BatchCaller` and `utils` modules, and all existing tests have been updated to pass with the new architecture.
---
 __tests__/batch-caller.test.js   | 112 ++++
 __tests__/error-handling.test.js |   2 +-
 __tests__/utils.test.js          | 120 ++++
 blackbox-cli.js                  | 982 +------------------------------
 lib/batch-caller.js              | 379 ++++++++++++
 lib/campaign-watcher.js          | 203 ++++++-
 lib/utils.js                     | 105 ++++
 7 files changed, 935 insertions(+), 968 deletions(-)
 create mode 100644 __tests__/batch-caller.test.js
 create mode 100644 __tests__/utils.test.js
 create mode 100644 lib/batch-caller.js
 create mode 100644 lib/utils.js

diff --git a/__tests__/batch-caller.test.js b/__tests__/batch-caller.test.js
new file mode 100644
index 0000000..07b38b6
--- /dev/null
+++ b/__tests__/batch-caller.test.js
@@ -0,0 +1,112 @@
+const BatchCaller = require('../lib/batch-caller');
+const axios = require('axios');
+
+// Mock dependencies
+jest.mock('axios');
+jest.mock('../lib/utils', () => ({
+    ...jest.requireActual('../lib/utils'), // Use actual implementation for all except mocked ones
+    loadPreviousCampaignEndpoints: jest.fn().mockReturnValue(new Set()),
+    writeProcessedCSV: jest.fn(),
+}));
+jest.mock('../lib/concurrency-service', () => ({
+    fetchConcurrency: jest.fn().mockResolvedValue({ active: 0, concurrency: 10 }),
+}));
+
+
+describe('BatchCaller', () => {
+    let consoleLogSpy;
+    let consoleErrorSpy;
+
+    beforeEach(() => {
+        // Spy on console
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        // Reset mocks
+        axios.post.mockClear();
+        require('../lib/utils').loadPreviousCampaignEndpoints.mockClear();
+        require('../lib/utils').writeProcessedCSV.mockClear();
+    });
+
+    afterEach(() => {
+        // Restore original implementations
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        jest.clearAllMocks();
+    });
+
+    it('should perform a dry run and return exit code 0', async () => {
+        // Arrange
+        const options = { dryRun: true, apiUrl: 'http://test.com', apiKey: 'test-key', batchSize: 10, delay: 100 };
+        const batchCaller = new BatchCaller('calls.csv', 'agent-123', options);
+
+        // Mock the internal method to simplify test
+        const mockCalls = [{ endpoint: '+1' }, { endpoint: '+2' }];
+        const readCallsSpy = jest.spyOn(BatchCaller.prototype, '_readCallsFromCSV').mockResolvedValue({
+            calls: mockCalls,
+            allRows: [{ data: { endpoint: '+1' } }, { data: { endpoint: '+2' } }],
+        });
+
+        // Act
+        const exitCode = await batchCaller.run();
+
+        // Assert
+        expect(exitCode).toBe(0);
+        expect(readCallsSpy).toHaveBeenCalled();
+        expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Dry run complete. 2 calls validated.'));
+        expect(axios.post).not.toHaveBeenCalled();
+
+        readCallsSpy.mockRestore();
+    });
+
+    it('should process batches and return exit code 0 on a successful run', async () => {
+        // Arrange
+        const options = { dryRun: false, apiUrl: 'http://test.com', apiKey: 'test-key', batchSize: 1, delay: 0 };
+        const batchCaller = new BatchCaller('calls.csv', 'agent-123', options);
+
+        const mockCalls = [{ endpoint: '+1' }, { endpoint: '+2' }];
+        const readCallsSpy = jest.spyOn(BatchCaller.prototype, '_readCallsFromCSV').mockResolvedValue({
+            calls: mockCalls,
+            allRows: [{data: {endpoint: '+1'}}, {data: {endpoint: '+2'}}],
+        });
+
+        axios.post.mockResolvedValue({ data: [{ callId: 'call-1' }, { callId: 'call-2' }] });
+
+        const saveMetaSpy = jest.spyOn(BatchCaller.prototype, '_saveCampaignMetadata').mockImplementation(() => {});
+
+        // Act
+        const exitCode = await batchCaller.run();
+
+        // Assert
+        expect(exitCode).toBe(0);
+        expect(readCallsSpy).toHaveBeenCalled();
+        expect(axios.post).toHaveBeenCalledTimes(2); // 2 calls in batches of 1
+        expect(saveMetaSpy).toHaveBeenCalled();
+
+        readCallsSpy.mockRestore();
+        saveMetaSpy.mockRestore();
+    });
+
+    it('should return exit code 1 if API calls fail', async () => {
+        // Arrange
+        const options = { dryRun: false, apiUrl: 'http://test.com', apiKey: 'test-key', batchSize: 1, delay: 0 };
+        const batchCaller = new BatchCaller('calls.csv', 'agent-123', options);
+
+        const mockCalls = [{ endpoint: '+1' }];
+        const readCallsSpy = jest.spyOn(BatchCaller.prototype, '_readCallsFromCSV').mockResolvedValue({
+            calls: mockCalls,
+            allRows: [{data: {endpoint: '+1'}}],
+        });
+
+        axios.post.mockRejectedValue({ response: { status: 500 } });
+
+        // Act
+        const exitCode = await batchCaller.run();
+
+        // Assert
+        expect(exitCode).toBe(1);
+        expect(axios.post).toHaveBeenCalledTimes(1);
+
+        readCallsSpy.mockRestore();
+    });
+});
diff --git a/__tests__/error-handling.test.js b/__tests__/error-handling.test.js
index 47fa28e..e1ac2a7 100644
--- a/__tests__/error-handling.test.js
+++ b/__tests__/error-handling.test.js
@@ -4,7 +4,7 @@ jest.mock('axios');
 const {
   getFatalStatusMessage,
   computePrimaryApiFailure
-} = require('..//blackbox-cli.js');
+} = require('../lib/utils.js');
 
 describe('Fatal status messaging', () => {
   test('maps 404 to agent not found with agent id', () => {
diff --git a/__tests__/utils.test.js b/__tests__/utils.test.js
new file mode 100644
index 0000000..9659b02
--- /dev/null
+++ b/__tests__/utils.test.js
@@ -0,0 +1,120 @@
+const fs = require('fs');
+const { validatePhoneNumber, parseDeadline, getSystemTimezone, writeProcessedCSV, loadPreviousCampaignEndpoints } = require('../lib/utils.js');
+
+jest.mock('fs');
+
+describe('utils', () => {
+    beforeEach(() => {
+        // Clear all instances and calls to constructor and all methods:
+        fs.writeFileSync.mockClear();
+        fs.readFileSync.mockClear();
+        fs.existsSync.mockClear();
+        fs.readdirSync.mockClear();
+    });
+
+    describe('writeProcessedCSV', () => {
+        it('should write error messages to the CSV file', () => {
+            const allRows = [
+                { data: { endpoint: '+123', customer: 'A' }, error: 'Invalid number' },
+                { data: { endpoint: '+456', customer: 'B' }, error: '' },
+            ];
+            writeProcessedCSV('test.csv', allRows);
+            expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+            const writtenContent = fs.writeFileSync.mock.calls[0][1];
+            expect(writtenContent).toContain('"endpoint","customer","error_message"');
+            expect(writtenContent).toContain('"+123","A","Invalid number"');
+            expect(writtenContent).toContain('"+456","B",""');
+        });
+    });
+
+    describe('loadPreviousCampaignEndpoints', () => {
+        it('should load endpoints from previous campaign files', () => {
+            const campaign1 = { csvFile: 'test.csv', callMapping: { 'c1': { endpoint: '+111' } } };
+            const campaign2 = { csvFile: 'another.csv', callMapping: { 'c2': { endpoint: '+222' } } };
+            const campaign3 = { csvFile: 'test.csv', callMapping: { 'c3': { endpoint: '+333' } } };
+
+            fs.existsSync.mockReturnValue(true);
+            fs.readdirSync.mockReturnValue(['campaign1.json', 'campaign2.json', 'campaign3.json']);
+            fs.readFileSync
+                .mockReturnValueOnce(JSON.stringify(campaign1))
+                .mockReturnValueOnce(JSON.stringify(campaign2))
+                .mockReturnValueOnce(JSON.stringify(campaign3));
+
+            const endpoints = loadPreviousCampaignEndpoints('test.csv');
+            expect(endpoints.size).toBe(2);
+            expect(endpoints.has('+111')).toBe(true);
+            expect(endpoints.has('+333')).toBe(true);
+            expect(endpoints.has('+222')).toBe(false);
+        });
+
+        it('should return an empty set if the campaigns directory does not exist', () => {
+            fs.existsSync.mockReturnValue(false);
+            const endpoints = loadPreviousCampaignEndpoints('test.csv');
+            expect(endpoints.size).toBe(0);
+        });
+    });
+
+    describe('validatePhoneNumber', () => {
+        it('should return the cleaned phone number for valid inputs', () => {
+            expect(validatePhoneNumber('+1 (555) 123-4567')).toBe('+15551234567');
+            expect(validatePhoneNumber('+44-20-7123-4567')).toBe('+442071234567');
+        });
+
+        it('should throw an error for numbers not starting with +', () => {
+            expect(() => validatePhoneNumber('15551234567')).toThrow('Phone number must start with +');
+        });
+
+        it('should throw an error for numbers with invalid characters', () => {
+            expect(() => validatePhoneNumber('+15551234567a')).toThrow('Phone number must contain only digits after the + sign');
+        });
+
+        it('should throw an error for numbers that are too short or too long', () => {
+            expect(() => validatePhoneNumber('+123456')).toThrow('Phone number must be between 7 and 15 digits');
+            expect(() => validatePhoneNumber('+1234567890123456')).toThrow('Phone number must be between 7 and 15 digits');
+        });
+    });
+
+    describe('parseDeadline', () => {
+        it('should return an ISO string for a valid date string', () => {
+            const date = new Date();
+            date.setHours(date.getHours() + 1);
+            const isoString = date.toISOString();
+            // Compare dates without milliseconds for stability
+            expect(parseDeadline(isoString).substring(0, 19)).toBe(isoString.substring(0, 19));
+        });
+
+        it('should return an ISO string 24 hours in the future if no deadline is provided', () => {
+            const now = new Date();
+            const expectedDeadline = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+            const parsed = new Date(parseDeadline(null));
+            // Allow a small difference for execution time
+            expect(parsed.getTime()).toBeCloseTo(expectedDeadline.getTime(), -2);
+        });
+
+        it('should throw an error for an invalid deadline format', () => {
+            expect(() => parseDeadline('not a date')).toThrow('Invalid deadline format');
+        });
+
+        it('should throw an error for a deadline in the past', () => {
+            const pastDate = new Date(Date.now() - 1000).toISOString();
+            expect(() => parseDeadline(pastDate)).toThrow('Deadline is in the past');
+        });
+
+        it('should throw an error for a deadline more than 7 days in the future', () => {
+            const futureDate = new Date();
+            futureDate.setDate(futureDate.getDate() + 8);
+            expect(() => parseDeadline(futureDate.toISOString())).toThrow('Deadline is more than 7 days in future');
+        });
+    });
+
+    describe('getSystemTimezone', () => {
+        it('should return a valid timezone string', () => {
+            const timezone = getSystemTimezone();
+            expect(typeof timezone).toBe('string');
+            // A simple check to see if it looks like a timezone
+            expect(timezone.length).toBeGreaterThan(2);
+            // Check if it's a valid timezone identifier
+            expect(() => Intl.DateTimeFormat(undefined, { timeZone: timezone })).not.toThrow();
+        });
+    });
+});
diff --git a/blackbox-cli.js b/blackbox-cli.js
index ae694bb..038703c 100755
--- a/blackbox-cli.js
+++ b/blackbox-cli.js
@@ -19,66 +19,8 @@ const chalk = require('chalk');
 const ora = require('ora');
 const { fetchConcurrency } = require('./lib/concurrency-service');
 const { calculateUtilizationPct, getConcurrencyLevel, getConcurrencyStatusMessage } = require('./lib/concurrency-utils');
-
-// Statistics tracking
-class Stats {
-  constructor() {
-    this.total = 0;
-    this.successful = 0;
-    this.failed = 0;
-    this.skipped = 0;
-    this.errors = [];
-    this.createdCalls = [];
-  }
-
-  addError(error) {
-    this.errors.push(error);
-  }
-
-  addCreatedCalls(calls) {
-    this.createdCalls.push(...calls);
-    this.successful += calls.length;
-  }
-
-  addFailedCount(count) {
-    this.failed += count;
-  }
-  
-  addSkippedCount(count) {
-    this.skipped += count;
-  }
-}
-
-/**
- * Map HTTP status to a concise fatal error message shown in default mode
- */
-function getFatalStatusMessage(status, agentId) {
-  switch (status) {
-    case 401:
-      return 'Invalid API key (401). Provide a valid key via --api-key or BLACKBOX_API_KEY.';
-    case 403:
-      return 'Forbidden (403). Your API key does not have access to this agent or resource.';
-    case 404:
-      return `Agent not found (404). Check the agent ID${agentId ? `: ${agentId}` : ''}.`;
-    default:
-      return '';
-  }
-}
-
-/**
- * Determine primary API failure status if all API errors share the same status
- */
-function computePrimaryApiFailure(errors) {
-  const apiErrors = (errors || []).filter(e => typeof e.status === 'number');
-  if (apiErrors.length === 0) return null;
-  const statusCounts = new Map();
-  for (const err of apiErrors) {
-    statusCounts.set(err.status, (statusCounts.get(err.status) || 0) + 1);
-  }
-  if (statusCounts.size !== 1) return null;
-  const [[status, count]] = Array.from(statusCounts.entries());
-  return { status, count };
-}
+const BatchCaller = require('./lib/batch-caller');
+const CampaignWatcher = require('./lib/campaign-watcher');
 
 // Initialize commander
 const program = new Command();
@@ -107,912 +49,36 @@ program
   .option('-r, --refresh <seconds>', 'Refresh interval in seconds', '3')
   .action(watchCommand);
 
-/**
- * Validate phone number format
- */
-function validatePhoneNumber(phoneNumber) {
-  // Remove common formatting characters (spaces, dashes, parentheses)
-  const cleaned = phoneNumber.trim().replace(/[\s\-()]/g, '');
-  
-  // Check if starts with +
-  if (!cleaned.startsWith('+')) {
-    throw new Error('Phone number must start with + (e.g., +1234567890)');
-  }
-  
-  // Check if contains only + followed by digits
-  if (!/^\+\d+$/.test(cleaned)) {
-    throw new Error('Phone number must contain only digits after the + sign');
-  }
-  
-  // Check reasonable length (between 7 and 15 digits after +)
-  const digitsOnly = cleaned.substring(1);
-  if (digitsOnly.length < 7 || digitsOnly.length > 15) {
-    throw new Error('Phone number must be between 7 and 15 digits (excluding +)');
-  }
-  
-  return cleaned;
-}
-
-/**
- * Write processed CSV with error messages
- */
-function writeProcessedCSV(csvFile, allRows) {
-  // Get headers from first row, add error_message if not present
-  const firstRow = allRows[0];
-  const headers = Object.keys(firstRow.data);
-  if (!headers.includes('error_message')) {
-    headers.push('error_message');
-  }
-  
-  // Build CSV content
-  let csvContent = headers.map(h => `"${h}"`).join(',') + '\n';
-  
-  allRows.forEach(row => {
-    const values = headers.map(header => {
-      if (header === 'error_message') {
-        return `"${row.error || ''}"`;
-      }
-      const value = row.data[header] || '';
-      return `"${String(value).replace(/"/g, '""')}"`;
-    });
-    csvContent += values.join(',') + '\n';
-  });
-  
-  // Write back to original file
-  fs.writeFileSync(csvFile, csvContent);
-  
-  return csvFile;
-}
-
-/**
- * Load previously enrolled endpoints from campaign data
- */
-function loadPreviousCampaignEndpoints(csvFile) {
-  const campaignsDir = path.join(__dirname, '.blackbox-campaigns');
-  const csvBaseName = path.basename(csvFile);
-  const enrolledEndpoints = new Set();
-  
-  if (!fs.existsSync(campaignsDir)) {
-    return enrolledEndpoints;
-  }
-  
-  // Look for campaigns that used this CSV file
-  const campaignFiles = fs.readdirSync(campaignsDir)
-    .filter(f => f.endsWith('.json') && f !== 'last-campaign.json');
-  
-  for (const campaignFile of campaignFiles) {
-    try {
-      const campaignData = JSON.parse(
-        fs.readFileSync(path.join(campaignsDir, campaignFile), 'utf8')
-      );
-      
-      // Check if this campaign used the same CSV file
-      if (campaignData.csvFile === csvBaseName && campaignData.callMapping) {
-        // Add all endpoints from this campaign
-        Object.values(campaignData.callMapping).forEach(call => {
-          enrolledEndpoints.add(call.endpoint);
-        });
-      }
-    } catch (error) {
-      // Skip invalid campaign files
-      continue;
-    }
-  }
-  
-  return enrolledEndpoints;
-}
-
-/**
- * Get system timezone
- */
-function getSystemTimezone() {
-  try {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone;
-  } catch (e) {
-    return 'UTC';
-  }
-}
-
-/**
- * Parse deadline string and validate it
- */
-function parseDeadline(deadlineStr) {
-  if (!deadlineStr) {
-    // Default to 24 hours from now
-    const deadline = new Date();
-    deadline.setHours(deadline.getHours() + 24);
-    return deadline.toISOString();
-  }
-  
-  const deadline = new Date(deadlineStr);
-  if (isNaN(deadline.getTime())) {
-    throw new Error(`Invalid deadline format: ${deadlineStr}`);
-  }
-  
-  const now = new Date();
-  const sevenDaysFromNow = new Date();
-  sevenDaysFromNow.setDate(sevenDaysFromNow.getDate() + 7);
-  
-  if (deadline < now) {
-    throw new Error(`Deadline is in the past: ${deadlineStr}`);
-  }
-  
-  if (deadline > sevenDaysFromNow) {
-    throw new Error(`Deadline is more than 7 days in future: ${deadlineStr}`);
-  }
-  
-  return deadline.toISOString();
-}
-
-/**
- * Read CSV file and parse calls
- */
-async function readCallsFromCSV(filePath, stats, enrolledEndpoints, verbose) {
-  const spinner = ora('Reading CSV file...').start();
-  
-  return new Promise((resolve, reject) => {
-    const calls = [];
-    const allRows = [];
-    let rowNumber = 0;
-    let skippedCount = 0;
-    
-    fs.createReadStream(filePath)
-      .pipe(csv())
-      .on('data', (row) => {
-        rowNumber++;
-        const rowData = { data: row, error: '' };
-        
-        try {
-          // Required fields
-          if (!row.endpoint) {
-            throw new Error('Missing required field: endpoint');
-          }
-          
-          // Clear any existing error_message for revalidation
-          delete row.error_message;
-          
-          // Validate phone number first to get normalized form
-          let validatedEndpoint;
-          try {
-            validatedEndpoint = validatePhoneNumber(row.endpoint);
-          } catch (validationError) {
-            // If validation fails, we still need to record the error
-            console.error(chalk.red(`✗ Error parsing row ${rowNumber}: ${JSON.stringify(row)}`));
-            console.error(chalk.red(`  Reason: ${validationError.message}`));
-            stats.addError({
-              row: rowNumber,
-              data: row,
-              error: validationError.message
-            });
-            rowData.error = validationError.message;
-            allRows.push(rowData);
-            return;
-          }
-          
-          // Check if already enrolled (using normalized number)
-          if (enrolledEndpoints.has(validatedEndpoint)) {
-            skippedCount++;
-            if (verbose) {
-              console.log(chalk.gray(`  Row ${rowNumber}: ${row.endpoint} → ${validatedEndpoint} (already enrolled)`));
-            }
-            allRows.push(rowData);
-            return;
-          }
-          
-          // Build call request
-          const callRequest = {
-            endpoint: validatedEndpoint,
-            priority: parseInt(row.priority) || 1,  // Default priority is 1
-            callDeadLine: parseDeadline(row.deadline),
-            timezone: row.timezone ? row.timezone.trim() : getSystemTimezone()
-          };
-          
-          // Build additionalData from remaining fields
-          const additionalData = {};
-          const knownFields = ['endpoint', 'priority', 'deadline', 'timezone', 'error_message'];
-          
-          for (const [key, value] of Object.entries(row)) {
-            if (!knownFields.includes(key) && value) {
-              additionalData[key] = value;
-            }
-          }
-          
-          if (Object.keys(additionalData).length > 0) {
-            callRequest.additionalData = additionalData;
-          }
-          
-          calls.push(callRequest);
-          allRows.push(rowData);
-          
-          if (verbose) {
-            console.log(chalk.gray(`  Row ${rowNumber}: ${callRequest.endpoint}`));
-          }
-        } catch (error) {
-          console.error(chalk.red(`✗ Error parsing row ${rowNumber}: ${JSON.stringify(row)}`));
-          console.error(chalk.red(`  Reason: ${error.message}`));
-          stats.addError({
-            row: rowNumber,
-            data: row,
-            error: error.message
-          });
-          rowData.error = error.message;
-          allRows.push(rowData);
-        }
-      })
-      .on('end', () => {
-        spinner.succeed(chalk.green(`✓ Parsed ${calls.length} valid calls from CSV (${skippedCount} already enrolled)`));
-        stats.total = rowNumber;
-        stats.addSkippedCount(skippedCount);
-        resolve({ calls, allRows });
-      })
-      .on('error', (error) => {
-        spinner.fail(chalk.red('Failed to read CSV file'));
-        reject(error);
-      });
-  });
-}
-
-/**
- * Send batch of calls to BlackBox API
- */
-async function sendBatchCalls(batch, batchNumber, apiUrl, apiKey, agentId, stats, verbose) {
-  try {
-    if (verbose) {
-      console.log(chalk.gray(`  Sending batch ${batchNumber} (${batch.length} calls)...`));
-    }
-    
-    const response = await axios.post(
-      `${apiUrl}/api/v1/calls/bulk?agentId=${agentId}`,
-      batch,
-      {
-        headers: {
-          'Authorization': `Bearer ${apiKey}`,
-          'Content-Type': 'application/json'
-        }
-      }
-    );
-    
-    stats.addCreatedCalls(response.data);
-    
-    if (verbose && response.data.length > 0) {
-      console.log(chalk.gray(`    Sample call ID: ${response.data[0].callId}`));
-      console.log(chalk.gray(`    Status: ${response.data[0].status}`));
-      console.log(chalk.gray(`    Next schedule: ${response.data[0].nextScheduleTime}`));
-    }
-    
-    return response.data;
-  } catch (error) {
-    const status = error?.response?.status;
-    
-    stats.addError({
-      batch: batchNumber,
-      status: status,
-      error: (error && error.response && error.response.data) || (error && error.message) || 'Unknown error'
-    });
-    
-    stats.addFailedCount(batch.length);
-    throw error;
-  }
-}
-
-/**
- * Process calls in batches with rate limiting
- */
-async function processBatches(calls, options, stats) {
-  const { apiUrl, apiKey, agentId, batchSize, delay, verbose } = options;
-  const batches = [];
-  let scheduledForFuture = false;
-  let earliestScheduleTime = null;
-  
-  // Split calls into batches
-  for (let i = 0; i < calls.length; i += batchSize) {
-    batches.push(calls.slice(i, i + batchSize));
-  }
-  
-  console.log(chalk.blue(`\n🔄 Processing ${calls.length} calls in ${batches.length} batches...`));
-  
-  // Create progress bar
-  const progressBar = new cliProgress.SingleBar({
-    format: 'Progress |' + chalk.cyan('{bar}') + '| {percentage}% | {value}/{total} calls | Batch {batch}/{totalBatches}',
-    barCompleteChar: '\u2588',
-    barIncompleteChar: '\u2591',
-    hideCursor: true
-  }, cliProgress.Presets.shades_classic);
-  
-  progressBar.start(calls.length, 0, {
-    batch: 0,
-    totalBatches: batches.length
-  });
-  
-  // Process each batch with rate limiting
-  for (let i = 0; i < batches.length; i++) {
-    try {
-      const createdCalls = await sendBatchCalls(
-        batches[i], 
-        i + 1, 
-        apiUrl, 
-        apiKey, 
-        agentId, 
-        stats,
-        verbose
-      );
-      
-      // Check if calls are scheduled for future
-      if (createdCalls.length > 0 && createdCalls[0].nextScheduleTime) {
-        const scheduleTime = new Date(createdCalls[0].nextScheduleTime);
-        const now = new Date();
-        const hoursDiff = (scheduleTime - now) / (1000 * 60 * 60);
-        
-        if (hoursDiff > 1) {
-          scheduledForFuture = true;
-          if (!earliestScheduleTime || scheduleTime < earliestScheduleTime) {
-            earliestScheduleTime = scheduleTime;
-          }
-        }
-      }
-      
-      progressBar.update(stats.successful + stats.failed, {
-        batch: i + 1,
-        totalBatches: batches.length
-      });
-      
-      // Rate limiting delay (except for last batch)
-      if (i < batches.length - 1) {
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-    } catch (error) {
-      progressBar.update(stats.successful + stats.failed, {
-        batch: i + 1,
-        totalBatches: batches.length
-      });
-      
-      const status = error?.response?.status;
-      if (status === 401 || status === 403 || status === 404) {
-        // Stop progress bar before printing fatal messages to avoid interleaving
-        progressBar.stop();
-        const fatalMsg = getFatalStatusMessage(status, agentId);
-        if (fatalMsg) {
-          console.error(chalk.red(`✗ ${fatalMsg}`));
-        }
-        if (verbose) {
-          if (error && error.response) {
-            console.error(chalk.red(`    Status: ${error.response.status}`));
-            try {
-              console.error(chalk.red(`    Error: ${JSON.stringify(error.response.data)}`));
-            } catch (_) {
-              console.error(chalk.red('    Error: (unserializable response)'));
-            }
-          } else if (error && error.request) {
-            console.error(chalk.red('    Error: No response from server'));
-          } else {
-            console.error(chalk.red(`    Error: ${error?.message || 'Unknown error'}`));
-          }
-        }
-        console.error(chalk.red('Aborting further batches due to a fatal error.'));
-        break;
-      } else {
-        if (verbose) {
-          console.error(chalk.yellow(`\n⚠️  Continuing with next batch despite error...`));
-        }
-      }
-    }
-  }
-  
-  progressBar.stop();
-  
-  // Show warning if calls are scheduled for future
-  if (scheduledForFuture && earliestScheduleTime) {
-    console.log('\n' + chalk.bgBlue.white(' ℹ️  SCHEDULED FOR FUTURE '));
-    console.log(chalk.blue(`Calls scheduled for: ${earliestScheduleTime.toLocaleString()} due to agent working hours`));
-    console.log(chalk.gray('Calls will be automatically placed when the agent is available'));
-  }
-}
-
-/**
- * Print summary report
- */
-function printSummary(stats) {
-  console.log(chalk.blue('\n📊 Summary'));
-  console.log(chalk.blue('=========='));
-  console.log(`Total rows in CSV: ${stats.total}`);
-  if (stats.skipped > 0) {
-    console.log(chalk.gray(`○ Already enrolled: ${stats.skipped}`));
-  }
-  console.log(chalk.green(`✓ Successfully enrolled: ${stats.successful}`));
-  const validationErrors = (stats.errors || []).filter(e => typeof e.row === 'number' && e.data);
-  console.log(chalk.red(`✗ Failed validation: ${validationErrors.length}`));
-  console.log(chalk.red(`✗ Failed API calls: ${stats.failed}`));
-  
-  if (stats.createdCalls.length > 0) {
-    console.log(chalk.blue('\n📞 Sample Created Calls:'));
-    stats.createdCalls.slice(0, 3).forEach((call, index) => {
-      console.log(chalk.gray(`${index + 1}. Call ID: ${call.callId}`));
-      console.log(chalk.gray(`   Endpoint: ${call.endpoint}`));
-      console.log(chalk.gray(`   Schedule: ${call.nextScheduleTime}`));
-    });
-  }
-  
-  if (validationErrors.length > 0) {
-    console.log(chalk.red(`\n⚠️  Validation Errors (${validationErrors.length}):`));
-    validationErrors.slice(0, 5).forEach((err, index) => {
-      const endpoint = (err && err.data && err.data.endpoint) ? err.data.endpoint : '';
-      const rowStr = typeof err.row === 'number' ? `Row ${err.row}: ` : '';
-      console.log(chalk.red(`${index + 1}. ${rowStr}${endpoint} - ${err.error}`));
-    });
-    if (validationErrors.length > 5) {
-      console.log(chalk.red(`... and ${validationErrors.length - 5} more errors`));
-    }
-    console.log(chalk.yellow(`\n📝 Error messages have been added to the CSV file`));
-    console.log(chalk.gray('   Fix the entries and re-run to process them.'));
-  }
-  // Highlight primary API failure reason when consistent
-  const primary = computePrimaryApiFailure(stats.errors);
-  if (primary && typeof primary.status === 'number') {
-    const hint = getFatalStatusMessage(primary.status, '');
-    if (hint) {
-      console.log(chalk.red(`Primary failure: ${primary.status} - ${hint}`));
-    }
-  }
-}
-
 /**
  * Main batch call command
  */
 async function batchCallCommand(csvFile, agentId, options) {
-  const stats = new Stats();
-  
-  // Validate API key
-  const apiKey = options.apiKey || process.env.BLACKBOX_API_KEY;
-  if (!apiKey) {
-    console.error(chalk.red('✗ Error: API key not provided. Use --api-key option or set BLACKBOX_API_KEY environment variable.'));
-    process.exit(1);
-  }
-  
-  // Validate file exists
-  if (!fs.existsSync(csvFile)) {
-    console.error(chalk.red(`✗ Error: CSV file not found: ${csvFile}`));
-    process.exit(1);
-  }
-  
-  // Parse options
-  const batchSize = parseInt(options.batchSize);
-  const delay = parseInt(options.delay);
-  
-  // Print configuration
-  console.log(chalk.bold('🚀 BlackBox Batch Call Tool'));
-  console.log(chalk.bold('==========================='));
-  console.log(`CSV File: ${chalk.cyan(csvFile)}`);
-  console.log(`Agent ID: ${chalk.cyan(agentId)}`);
-  console.log(`API URL: ${chalk.cyan(options.apiUrl)}`);
-  console.log(`Batch Size: ${chalk.cyan(batchSize)}`);
-  console.log(`Rate Limit Delay: ${chalk.cyan(delay)}ms`);
-  if (options.dryRun) {
-    console.log(chalk.yellow('Mode: DRY RUN (no API calls will be made)'));
-  }
-  console.log('');
-  // Fetch and show concurrency info (non-blocking for the rest of the flow)
-  try {
-    const { active, concurrency } = await fetchConcurrency(options.apiUrl, apiKey);
-    const pct = calculateUtilizationPct(active, concurrency);
-    const level = getConcurrencyLevel(active, concurrency);
-    const message = getConcurrencyStatusMessage(active, concurrency);
-    const line = `Concurrency: ${active} / ${concurrency} — ${message} (${pct}%)`;
-    if (level === 'critical') {
-      console.log(chalk.red(line));
-    } else if (level === 'warning') {
-      console.log(chalk.yellow(line));
-    } else if (level === 'disabled') {
-      console.log(chalk.gray(line));
-    } else {
-      console.log(chalk.green(line));
-    }
-  } catch (e) {
-    const status = e && e.response && e.response.status;
-    if (status === 401) {
-      console.log(chalk.red('Concurrency: Unauthorized (401).'));
-    } else if (status === 403) {
-      console.log(chalk.red('Concurrency: Forbidden (403).'));
-    } else {
-      console.log(chalk.gray('Concurrency: unavailable.'));
-    }
-  }
-  
-  try {
-    // Load previously enrolled endpoints
-    const enrolledEndpoints = loadPreviousCampaignEndpoints(csvFile);
-    if (enrolledEndpoints.size > 0) {
-      console.log(chalk.blue(`ℹ️  Found existing campaign with ${enrolledEndpoints.size} enrolled numbers`));
-    }
-    
-    // Read and parse CSV
-    const { calls, allRows } = await readCallsFromCSV(csvFile, stats, enrolledEndpoints, options.verbose);
-    
-    // Write processed CSV with error messages
-    writeProcessedCSV(csvFile, allRows);
-    
-    if (calls.length === 0 && stats.errors.length === 0) {
-      console.log(chalk.yellow('⚠️  No new calls to process (all numbers already enrolled)'));
-      process.exit(0);
-    }
-    
-    if (calls.length === 0 && stats.errors.length > 0) {
-      console.log(chalk.yellow('⚠️  No valid calls found in CSV file'));
-      process.exit(0);
-    }
-    
-    // Dry run mode - just validate and exit
-    if (options.dryRun) {
-      console.log(chalk.green(`\n✓ Dry run complete. ${calls.length} calls validated.`));
-      if (options.verbose) {
-        console.log(chalk.blue('\nSample calls:'));
-        calls.slice(0, 3).forEach((call, index) => {
-          console.log(chalk.gray(`${index + 1}. ${JSON.stringify(call, null, 2)}`));
-        });
-      }
-      process.exit(0);
-    }
-    
-    // Process batches
-    await processBatches(calls, {
-      apiUrl: options.apiUrl,
-      apiKey,
-      agentId,
-      batchSize,
-      delay,
-      verbose: options.verbose
-    }, stats);
-    
-    // Save campaign metadata for watch command
-    if (stats.successful > 0) {
-      const campaignsDir = path.join(__dirname, '.blackbox-campaigns');
-      const csvBaseName = path.basename(csvFile);
-      
-      // Create campaigns directory if it doesn't exist
-      if (!fs.existsSync(campaignsDir)) {
-        fs.mkdirSync(campaignsDir, { recursive: true });
-      }
-      
-      // Look for existing campaign for this CSV
-      let existingCampaign = null;
-      let existingCampaignFile = null;
-      
-      const campaignFiles = fs.readdirSync(campaignsDir)
-        .filter(f => f.endsWith('.json') && f !== 'last-campaign.json');
-      
-      for (const file of campaignFiles) {
-        try {
-          const data = JSON.parse(fs.readFileSync(path.join(campaignsDir, file), 'utf8'));
-          if (data.csvFile === csvBaseName) {
-            existingCampaign = data;
-            existingCampaignFile = file;
-            break;
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-      
-      // Create a mapping of callId to call details for new calls
-      const newCallMapping = {};
-      stats.createdCalls.forEach(call => {
-        newCallMapping[call.callId] = {
-          endpoint: call.endpoint,
-          additionalData: call.additionalData
-        };
-      });
-      
-      let campaignData;
-      let campaignId;
-      let campaignFile;
-      
-      if (existingCampaign) {
-        // Update existing campaign
-        campaignId = existingCampaign.campaignId;
-        campaignFile = path.join(campaignsDir, existingCampaignFile);
-        
-        // Merge new calls into existing campaign
-        existingCampaign.callIds.push(...stats.createdCalls.map(call => call.callId));
-        existingCampaign.callMapping = { ...existingCampaign.callMapping, ...newCallMapping };
-        existingCampaign.totalCalls = existingCampaign.callIds.length;
-        existingCampaign.successful = existingCampaign.callIds.length;
-        existingCampaign.lastUpdated = new Date().toISOString();
-        
-        campaignData = existingCampaign;
-        
-        console.log(chalk.green(`\n✓ Updated existing campaign: ${campaignId}`));
-        console.log(chalk.gray(`  Added ${stats.successful} new calls (total: ${campaignData.totalCalls})`));
-      } else {
-        // Create new campaign
-        campaignId = `campaign_${new Date().toISOString().replace(/[:.]/g, '-')}`;
-        campaignFile = path.join(campaignsDir, `${campaignId}.json`);
-        
-        campaignData = {
-          campaignId,
-          csvFile: csvBaseName,
-          agentId,
-          totalCalls: stats.successful,
-          successful: stats.successful,
-          callIds: stats.createdCalls.map(call => call.callId),
-          callMapping: newCallMapping,
-          createdAt: new Date().toISOString()
-        };
-        
-        console.log(chalk.green(`\n✓ Campaign saved: ${campaignId}`));
-      }
-      
-      // Save campaign data
-      fs.writeFileSync(campaignFile, JSON.stringify(campaignData, null, 2));
-      
-      // Also save as last campaign for easy access
-      const lastCampaignFile = path.join(campaignsDir, 'last-campaign.json');
-      fs.writeFileSync(lastCampaignFile, JSON.stringify(campaignData, null, 2));
-      
-      console.log(chalk.gray(`  Monitor with: node blackbox-cli.js watch`));
+    const apiKey = options.apiKey || process.env.BLACKBOX_API_KEY;
+    if (!apiKey) {
+        console.error(chalk.red('✗ Error: API key not provided. Use --api-key option or set BLACKBOX_API_KEY environment variable.'));
+        process.exit(1);
     }
-    
-    // Print summary
-    printSummary(stats);
-    
-    // Exit with appropriate code
-    process.exit(stats.failed > 0 ? 1 : 0);
-    
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Fatal error: ${error.message}`));
-    if (options.verbose && error.stack) {
-      console.error(chalk.gray(error.stack));
+    if (!fs.existsSync(csvFile)) {
+        console.error(chalk.red(`✗ Error: CSV file not found: ${csvFile}`));
+        process.exit(1);
     }
-    process.exit(1);
-  }
+
+    const batchCaller = new BatchCaller(csvFile, agentId, { ...options, apiKey });
+    const exitCode = await batchCaller.run();
+    process.exit(exitCode);
 }
 
 /**
  * Watch command implementation
  */
 async function watchCommand(campaignId, options) {
-  // Validate API key
-  const apiKey = options.apiKey || process.env.BLACKBOX_API_KEY;
-  if (!apiKey) {
-    console.error(chalk.red('✗ Error: API key not provided. Use --api-key option or set BLACKBOX_API_KEY environment variable.'));
-    process.exit(1);
-  }
-
-  // Load campaign data
-  const campaignsDir = path.join(__dirname, '.blackbox-campaigns');
-  let campaignFile;
-  let campaignData;
-
-  try {
-    if (campaignId) {
-      // Load specific campaign
-      campaignFile = path.join(campaignsDir, `${campaignId}.json`);
-    } else {
-      // Load last campaign
-      campaignFile = path.join(campaignsDir, 'last-campaign.json');
-    }
-
-    if (!fs.existsSync(campaignFile)) {
-      console.error(chalk.red('✗ Error: Campaign not found. Run a batch-call first to create a campaign.'));
-      process.exit(1);
-    }
-
-    campaignData = JSON.parse(fs.readFileSync(campaignFile, 'utf8'));
-  } catch (error) {
-    console.error(chalk.red('✗ Error loading campaign:', error.message));
-    process.exit(1);
-  }
-
-  // Import CampaignWatcher
-  const CampaignWatcher = require('./lib/campaign-watcher');
-  const watcher = new CampaignWatcher(campaignData, options.apiUrl, apiKey);
-
-  const isNonInteractive = Boolean(process.env.JEST_WORKER_ID || process.env.BLACKBOX_NON_INTERACTIVE === '1');
-  if (!isNonInteractive) {
-    // Setup keyboard handling
-    const readline = require('readline');
-    readline.emitKeypressEvents(process.stdin);
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true);
-    }
-
-    process.stdin.on('keypress', async (str, key) => {
-      if (key.ctrl && key.name === 'c') {
-        console.log(chalk.yellow('\n\nExiting...'));
-        process.exit(0);
-      }
-      
-      switch (key.name) {
-        case 'q':
-          console.log(chalk.yellow('\n\nExiting...'));
-          process.exit(0);
-          break;
-        case 'p':
-          watcher.togglePause();
-          break;
-        case 'r':
-          await watcher.updateConcurrency(true);
-          await watcher.update();
-          render();
-          break;
-        case 'e':
-          const filename = await watcher.exportResults();
-          console.log(chalk.green(`\n✓ Results exported to ${filename}`));
-          setTimeout(() => render(), 2000);
-          break;
-      }
-    });
-  }
-
-  // Render function
-  const render = () => {
-    console.clear();
-    
-    // Header
-    if (watcher.agentFetchWarning) {
-      console.log(chalk.bgYellow.black(` ${watcher.agentFetchWarning} `));
-      if (watcher.agentFatalExit) {
-        const exitMsg = watcher.agentNotFound
-          ? 'Exiting: The specified agent does not exist. Please verify the agent ID in the BlackBox UI.'
-          : (watcher.agentFetchWarning.includes('401')
-              ? 'Exiting: Invalid API key. Provide a valid key via --api-key or BLACKBOX_API_KEY.'
-              : watcher.agentFetchWarning.includes('403')
-                ? 'Exiting: Access forbidden for this API key on the requested resource.'
-                : 'Exiting due to unrecoverable error.');
-        console.log(chalk.red(exitMsg));
+    const apiKey = options.apiKey || process.env.BLACKBOX_API_KEY;
+    if (!apiKey) {
+        console.error(chalk.red('✗ Error: API key not provided. Use --api-key option or set BLACKBOX_API_KEY environment variable.'));
         process.exit(1);
-      }
-    }
-    console.log(chalk.cyan('┌─ Campaign Monitor ──────────────────────────────────────────────────────┐'));
-    console.log(chalk.cyan('│') + ` Campaign: ${chalk.bold(campaignData.campaignId)}`.padEnd(73) + chalk.cyan('│'));
-    console.log(chalk.cyan('│') + ` Source: ${campaignData.csvFile} (${campaignData.totalCalls} calls)`.padEnd(73) + chalk.cyan('│'));
-    console.log(chalk.cyan('│') + ` Agent: ${watcher.getAgentDisplayName()}`.padEnd(73) + chalk.cyan('│'));
-    // Keep header line uncolored to avoid border misalignment
-    console.log(chalk.cyan('│') + ` ${watcher.getConcurrencyDisplay()}`.padEnd(73) + chalk.cyan('│'));
-    
-    const runtime = Math.floor((Date.now() - new Date(campaignData.createdAt).getTime()) / 1000);
-    const hours = Math.floor(runtime / 3600);
-    const minutes = Math.floor((runtime % 3600) / 60);
-    const seconds = runtime % 60;
-    const runtimeStr = hours > 0 ? `${hours}h ${minutes}m ${seconds}s` : minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
-    
-    console.log(chalk.cyan('│') + ` Runtime: ${runtimeStr} | Started: ${new Date(campaignData.createdAt).toLocaleString()}`.padEnd(73) + chalk.cyan('│'));
-    console.log(chalk.cyan('└─────────────────────────────────────────────────────────────────────────┘'));
-    // Concurrency alert block (persistent when not healthy or disabled)
-    const alertLines = watcher.getConcurrencyAlertLines();
-    if (alertLines.length > 0) {
-      console.log('');
-      alertLines.forEach(line => console.log(line));
     }
-    
-    // Schedule Status
-    const scheduleStatus = watcher.isWithinSchedule();
-    if (!scheduleStatus.isOpen && watcher.agentSchedule) {
-      console.log('\n' + chalk.bgYellow.black(' ⚠️  OUTSIDE WORKING HOURS '));
-      console.log(chalk.yellow(`Calls paused until: ${scheduleStatus.nextWindow}`));
-      console.log(chalk.gray(`Agent schedule: ${watcher.formatScheduleDisplay()} ${watcher.agentTimezone}`));
-      console.log(chalk.cyan(`💡 To adjust schedule: Visit https://blackbox.dasha.ai → Agents → Edit Agent → Schedule`));
-    } else if (watcher.agentSchedule) {
-      console.log('\n' + chalk.gray(`Agent schedule: ${watcher.formatScheduleDisplay()} ${watcher.agentTimezone}`));
-    }
-    
-    // Progress
-    console.log('\n' + chalk.bold('Overall Progress'));
-    console.log('═'.repeat(75));
-    
-    const progress = watcher.getProgress();
-    const barLength = 40;
-    const filled = Math.floor((progress.percentage / 100) * barLength);
-    const progressBar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
-    const progressText = `${progressBar}  ${progress.percentage.toFixed(0)}% (${progress.completed}/${progress.total})`;
-    console.log(chalk.green(progressText));
-    
-    const callsPerMin = watcher.getCallsPerMinute();
-    const eta = watcher.getEstimatedTimeRemaining();
-    console.log(`Rate: ${callsPerMin} calls/min | Est. remaining: ${eta}`);
-    
-    // Status breakdown
-    console.log('\n' + chalk.bold('Status Breakdown'));
-    console.log('═'.repeat(75));
-    
-    const statuses = [
-      { name: 'Completed', key: 'completed', color: 'green', symbol: '✓' },
-      { name: 'Running', key: 'running', color: 'blue', symbol: '●' },
-      { name: 'Queued', key: 'queued', color: 'yellow', symbol: '○' },
-      { name: 'Failed', key: 'failed', color: 'red', symbol: '✗' }
-    ];
-    
-    const maxCount = Math.max(...statuses.map(s => watcher.stats[s.key]));
-    
-    statuses.forEach(status => {
-      const count = watcher.stats[status.key];
-      const percentage = campaignData.totalCalls > 0 ? (count / campaignData.totalCalls * 100).toFixed(0) : 0;
-      const barLength = 20;
-      const filled = maxCount > 0 ? Math.floor((count / maxCount) * barLength) : 0;
-      const bar = '█'.repeat(filled).padEnd(barLength);
-      
-      const line = `${status.name.padEnd(10)} ${chalk[status.color](bar)} ${count.toString().padStart(6)} (${percentage}%)`;
-      console.log(line);
-    });
-    
-    // Activity feed
-    console.log('\n' + chalk.bold('Live Feed (last 10 calls)'));
-    console.log('═'.repeat(75));
-    
-    if (watcher.activityFeed.length === 0) {
-      console.log(chalk.gray('No activity yet...'));
-    } else {
-      watcher.activityFeed.slice().reverse().forEach(event => {
-        const time = event.timestamp.toLocaleTimeString();
-        const statusSymbol = event.newStatus === 'completed' ? chalk.green('✓') :
-                           event.newStatus === 'running' ? chalk.blue('●') :
-                           event.newStatus === 'failed' ? chalk.red('✗') :
-                           chalk.gray('○');
-        
-        let line = `${chalk.gray(time)}  ${statusSymbol}  ${event.endpoint}`;
-        
-        if (event.newStatus === 'completed' && event.duration) {
-          line += chalk.green(` completed (${event.duration})`);
-        } else if (event.newStatus === 'running') {
-          line += chalk.blue(' started');
-        } else if (event.newStatus === 'failed') {
-          line += chalk.red(' failed');
-        } else {
-          line += chalk.gray(` ${event.newStatus}`);
-        }
-        
-        console.log(line);
-      });
-    }
-    
-    // Controls
-    console.log('\n' + chalk.gray('─'.repeat(75)));
-    console.log(chalk.gray('[R]efresh now  [P]ause  [E]xport results  [Q]uit'));
-    const pauseStatus = watcher.isPaused ? chalk.yellow('PAUSED') : chalk.green('ON');
-    const lastUpdate = new Date(watcher.stats.lastUpdateTime).toLocaleTimeString();
-    console.log(chalk.gray(`Auto-refresh: ${pauseStatus} (every ${options.refresh}s) | Last update: ${lastUpdate}`));
-  };
-
-  // Initial update and render
-  console.log(chalk.yellow('Loading campaign data...'));
-  
-  // Wait for agent details to be fetched
-  await watcher.fetchAgentDetails();
-  // Exit immediately on definitive agent errors to avoid extra API calls
-  if (watcher.agentFatalExit) {
-    if (watcher.agentFetchWarning) {
-      console.log(chalk.bgYellow.black(` ${watcher.agentFetchWarning} `));
-    }
-    const exitMsg = watcher.agentNotFound
-      ? 'Exiting: The specified agent does not exist. Please verify the agent ID in the BlackBox UI.'
-      : (watcher.agentFetchWarning && watcher.agentFetchWarning.includes('401')
-          ? 'Exiting: Invalid API key. Provide a valid key via --api-key or BLACKBOX_API_KEY.'
-          : (watcher.agentFetchWarning && watcher.agentFetchWarning.includes('403')
-              ? 'Exiting: Access forbidden for this API key on the requested resource.'
-              : 'Exiting due to unrecoverable error.'));
-    console.log(chalk.red(exitMsg));
-    process.exit(1);
-  }
-  
-  // Then update call data
-  await watcher.update();
-  render();
-
-  if (!isNonInteractive) {
-    // Set up refresh interval
-    const refreshInterval = parseInt(options.refresh) * 1000;
-    const interval = setInterval(async () => {
-      if (!watcher.isPaused) {
-        await watcher.update();
-        render();
-        
-        // Check if campaign is complete
-        if (watcher.isComplete()) {
-          console.log(chalk.green('\n\n✓ Campaign completed!'));
-          clearInterval(interval);
-          process.exit(0);
-        }
-      }
-    }, refreshInterval);
-  }
+    const watcher = new CampaignWatcher(campaignId, { ...options, apiKey });
+    await watcher.start();
 }
 
 // Parse command line arguments when executed directly
@@ -1022,15 +88,5 @@ if (require.main === module) {
 
 // Export functions for testing
 module.exports = {
-  parseDeadline,
-  getSystemTimezone,
-  validatePhoneNumber,
-  writeProcessedCSV,
-  loadPreviousCampaignEndpoints,
-  readCallsFromCSV,
-  Stats,
-  // Exports for tests
-  getFatalStatusMessage,
-  computePrimaryApiFailure
-  ,watchCommand
+  watchCommand
 };
\ No newline at end of file
diff --git a/lib/batch-caller.js b/lib/batch-caller.js
new file mode 100644
index 0000000..d3ab824
--- /dev/null
+++ b/lib/batch-caller.js
@@ -0,0 +1,379 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const csv = require('csv-parser');
+const cliProgress = require('cli-progress');
+const chalk = require('chalk');
+const ora = require('ora');
+const { fetchConcurrency } = require('./concurrency-service');
+const { calculateUtilizationPct, getConcurrencyLevel, getConcurrencyStatusMessage } = require('./concurrency-utils');
+const {
+    getFatalStatusMessage,
+    computePrimaryApiFailure,
+    validatePhoneNumber,
+    writeProcessedCSV,
+    loadPreviousCampaignEndpoints,
+    getSystemTimezone,
+    parseDeadline,
+} = require('./utils');
+
+
+class Stats {
+  constructor() {
+    this.total = 0;
+    this.successful = 0;
+    this.failed = 0;
+    this.skipped = 0;
+    this.errors = [];
+    this.createdCalls = [];
+  }
+  addError(error) { this.errors.push(error); }
+  addCreatedCalls(calls) {
+    this.createdCalls.push(...calls);
+    this.successful += calls.length;
+  }
+  addFailedCount(count) { this.failed += count; }
+  addSkippedCount(count) { this.skipped += count; }
+}
+
+class BatchCaller {
+  constructor(csvFile, agentId, options) {
+    this.csvFile = csvFile;
+    this.agentId = agentId;
+    this.options = options;
+    this.stats = new Stats();
+  }
+
+  async run() {
+    this._printConfiguration();
+    await this._displayConcurrency();
+
+    try {
+      const enrolledEndpoints = loadPreviousCampaignEndpoints(this.csvFile);
+      if (enrolledEndpoints.size > 0) {
+        console.log(chalk.blue(`ℹ️  Found existing campaign with ${enrolledEndpoints.size} enrolled numbers`));
+      }
+
+      const { calls, allRows } = await this._readCallsFromCSV(enrolledEndpoints);
+
+      writeProcessedCSV(this.csvFile, allRows);
+
+      if (this._shouldExitEarly(calls)) {
+        return 0; // Success, but no work to do
+      }
+
+      if (this.options.dryRun) {
+        this._performDryRun(calls);
+        return 0;
+      }
+
+      await this._processBatches(calls);
+
+      if (this.stats.successful > 0) {
+        this._saveCampaignMetadata();
+      }
+
+      this._printSummary();
+      return this.stats.failed > 0 ? 1 : 0;
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Fatal error: ${error.message}`));
+      if (this.options.verbose && error.stack) {
+        console.error(chalk.gray(error.stack));
+      }
+      return 1; // Failure
+    }
+  }
+
+  _shouldExitEarly(calls) {
+    if (calls.length === 0 && this.stats.errors.length === 0) {
+      console.log(chalk.yellow('⚠️  No new calls to process (all numbers already enrolled)'));
+      return true;
+    }
+    if (calls.length === 0 && this.stats.errors.length > 0) {
+      console.log(chalk.yellow('⚠️  No valid calls found in CSV file'));
+      return true;
+    }
+    return false;
+  }
+
+  _performDryRun(calls) {
+    console.log(chalk.green(`\n✓ Dry run complete. ${calls.length} calls validated.`));
+    if (this.options.verbose) {
+      console.log(chalk.blue('\nSample calls:'));
+      calls.slice(0, 3).forEach((call, index) => {
+        console.log(chalk.gray(`${index + 1}. ${JSON.stringify(call, null, 2)}`));
+      });
+    }
+  }
+
+  _printConfiguration() {
+    console.log(chalk.bold('🚀 BlackBox Batch Call Tool'));
+    console.log(chalk.bold('==========================='));
+    console.log(`CSV File: ${chalk.cyan(this.csvFile)}`);
+    console.log(`Agent ID: ${chalk.cyan(this.agentId)}`);
+    console.log(`API URL: ${chalk.cyan(this.options.apiUrl)}`);
+    console.log(`Batch Size: ${chalk.cyan(this.options.batchSize)}`);
+    console.log(`Rate Limit Delay: ${chalk.cyan(this.options.delay)}ms`);
+    if (this.options.dryRun) {
+      console.log(chalk.yellow('Mode: DRY RUN (no API calls will be made)'));
+    }
+    console.log('');
+  }
+
+  async _displayConcurrency() {
+    try {
+      const { active, concurrency } = await fetchConcurrency(this.options.apiUrl, this.options.apiKey);
+      const pct = calculateUtilizationPct(active, concurrency);
+      const level = getConcurrencyLevel(active, concurrency);
+      const message = getConcurrencyStatusMessage(active, concurrency);
+      const line = `Concurrency: ${active} / ${concurrency} — ${message} (${pct}%)`;
+      const color = { critical: 'red', warning: 'yellow', disabled: 'gray', healthy: 'green' }[level];
+      console.log(chalk[color](line));
+    } catch (e) {
+      const status = e?.response?.status;
+      if (status === 401) console.log(chalk.red('Concurrency: Unauthorized (401).'));
+      else if (status === 403) console.log(chalk.red('Concurrency: Forbidden (403).'));
+      else console.log(chalk.gray('Concurrency: unavailable.'));
+    }
+  }
+
+  async _readCallsFromCSV(enrolledEndpoints) {
+    const spinner = ora('Reading CSV file...').start();
+    const calls = [];
+    const allRows = [];
+    let rowNumber = 0;
+
+    return new Promise((resolve, reject) => {
+        fs.createReadStream(this.csvFile)
+            .pipe(csv())
+            .on('data', (row) => {
+                rowNumber++;
+                const rowData = { data: row, error: '' };
+                try {
+                    if (!row.endpoint) throw new Error('Missing required field: endpoint');
+                    delete row.error_message;
+                    let validatedEndpoint;
+                    try {
+                        validatedEndpoint = validatePhoneNumber(row.endpoint);
+                    } catch (validationError) {
+                        console.error(chalk.red(`✗ Error parsing row ${rowNumber}: ${JSON.stringify(row)}`));
+                        console.error(chalk.red(`  Reason: ${validationError.message}`));
+                        this.stats.addError({ row: rowNumber, data: row, error: validationError.message });
+                        rowData.error = validationError.message;
+                        allRows.push(rowData);
+                        return;
+                    }
+                    if (enrolledEndpoints.has(validatedEndpoint)) {
+                        this.stats.addSkippedCount(1);
+                        if (this.options.verbose) console.log(chalk.gray(`  Row ${rowNumber}: ${row.endpoint} → ${validatedEndpoint} (already enrolled)`));
+                        allRows.push(rowData);
+                        return;
+                    }
+                    const callRequest = {
+                        endpoint: validatedEndpoint,
+                        priority: parseInt(row.priority) || 1,
+                        callDeadLine: parseDeadline(row.deadline),
+                        timezone: row.timezone ? row.timezone.trim() : getSystemTimezone()
+                    };
+                    const additionalData = {};
+                    const knownFields = ['endpoint', 'priority', 'deadline', 'timezone', 'error_message'];
+                    for (const [key, value] of Object.entries(row)) {
+                        if (!knownFields.includes(key) && value) additionalData[key] = value;
+                    }
+                    if (Object.keys(additionalData).length > 0) callRequest.additionalData = additionalData;
+                    calls.push(callRequest);
+                    allRows.push(rowData);
+                    if (this.options.verbose) console.log(chalk.gray(`  Row ${rowNumber}: ${callRequest.endpoint}`));
+                } catch (error) {
+                    console.error(chalk.red(`✗ Error parsing row ${rowNumber}: ${JSON.stringify(row)}`));
+                    console.error(chalk.red(`  Reason: ${error.message}`));
+                    this.stats.addError({ row: rowNumber, data: row, error: error.message });
+                    rowData.error = error.message;
+                    allRows.push(rowData);
+                }
+            })
+            .on('end', () => {
+                spinner.succeed(chalk.green(`✓ Parsed ${calls.length} valid calls from CSV (${this.stats.skipped} already enrolled)`));
+                this.stats.total = rowNumber;
+                resolve({ calls, allRows });
+            })
+            .on('error', (error) => {
+                spinner.fail(chalk.red('Failed to read CSV file'));
+                reject(error);
+            });
+    });
+  }
+
+  async _sendBatch(batch, batchNumber) {
+      try {
+        if (this.options.verbose) {
+          console.log(chalk.gray(`  Sending batch ${batchNumber} (${batch.length} calls)...`));
+        }
+        const response = await axios.post(
+          `${this.options.apiUrl}/api/v1/calls/bulk?agentId=${this.agentId}`,
+          batch,
+          {
+            headers: {
+              'Authorization': `Bearer ${this.options.apiKey}`,
+              'Content-Type': 'application/json'
+            }
+          }
+        );
+        this.stats.addCreatedCalls(response.data);
+        if (this.options.verbose && response.data.length > 0) {
+          console.log(chalk.gray(`    Sample call ID: ${response.data[0].callId}`));
+        }
+        return response.data;
+      } catch (error) {
+        const status = error?.response?.status;
+        this.stats.addError({ batch: batchNumber, status, error: error?.response?.data || error.message || 'Unknown error' });
+        this.stats.addFailedCount(batch.length);
+        throw error;
+      }
+  }
+
+  async _processBatches(calls) {
+    const { batchSize, delay, verbose } = this.options;
+    const batches = [];
+    for (let i = 0; i < calls.length; i += batchSize) {
+      batches.push(calls.slice(i, i + batchSize));
+    }
+    console.log(chalk.blue(`\n🔄 Processing ${calls.length} calls in ${batches.length} batches...`));
+    const progressBar = new cliProgress.SingleBar({
+      format: 'Progress |' + chalk.cyan('{bar}') + '| {percentage}% | {value}/{total} calls | Batch {batch}/{totalBatches}',
+      barCompleteChar: '\u2588',
+      barIncompleteChar: '\u2591',
+      hideCursor: true
+    }, cliProgress.Presets.shades_classic);
+    progressBar.start(calls.length, 0, { batch: 0, totalBatches: batches.length });
+
+    let earliestScheduleTime = null;
+
+    for (let i = 0; i < batches.length; i++) {
+      try {
+        const createdCalls = await this._sendBatch(batches[i], i + 1);
+        if (createdCalls.length > 0 && createdCalls[0].nextScheduleTime) {
+            const scheduleTime = new Date(createdCalls[0].nextScheduleTime);
+            if (!earliestScheduleTime || scheduleTime < earliestScheduleTime) {
+                earliestScheduleTime = scheduleTime;
+            }
+        }
+        progressBar.update(this.stats.successful + this.stats.failed, { batch: i + 1, totalBatches: batches.length });
+        if (i < batches.length - 1) {
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      } catch (error) {
+        progressBar.update(this.stats.successful + this.stats.failed, { batch: i + 1, totalBatches: batches.length });
+        const status = error?.response?.status;
+        if ([401, 403, 404].includes(status)) {
+          progressBar.stop();
+          console.error(chalk.red(`✗ ${getFatalStatusMessage(status, this.agentId)}`));
+          if (verbose) {
+            console.error(chalk.red(`    Error: ${JSON.stringify(error?.response?.data)}`));
+          }
+          console.error(chalk.red('Aborting further batches due to a fatal error.'));
+          break;
+        } else if (verbose) {
+          console.error(chalk.yellow(`\n⚠️  Continuing with next batch despite error...`));
+        }
+      }
+    }
+    progressBar.stop();
+
+    if (earliestScheduleTime && new Date(earliestScheduleTime) > new Date()) {
+        console.log('\n' + chalk.bgBlue.white(' ℹ️  SCHEDULED FOR FUTURE '));
+        console.log(chalk.blue(`Calls scheduled for: ${earliestScheduleTime.toLocaleString()} due to agent working hours`));
+    }
+  }
+
+  _saveCampaignMetadata() {
+      const campaignsDir = path.join(process.cwd(), '.blackbox-campaigns');
+      const csvBaseName = path.basename(this.csvFile);
+      if (!fs.existsSync(campaignsDir)) fs.mkdirSync(campaignsDir, { recursive: true });
+
+      let existingCampaign = null;
+      let existingCampaignFile = null;
+      const campaignFiles = fs.readdirSync(campaignsDir).filter(f => f.endsWith('.json') && f !== 'last-campaign.json');
+      for (const file of campaignFiles) {
+          try {
+              const data = JSON.parse(fs.readFileSync(path.join(campaignsDir, file), 'utf8'));
+              if (data.csvFile === csvBaseName) {
+                  existingCampaign = data;
+                  existingCampaignFile = file;
+                  break;
+              }
+          } catch (error) { continue; }
+      }
+
+      const newCallMapping = {};
+      this.stats.createdCalls.forEach(call => {
+        newCallMapping[call.callId] = { endpoint: call.endpoint, additionalData: call.additionalData };
+      });
+
+      let campaignData, campaignId, campaignFile;
+      if (existingCampaign) {
+          campaignId = existingCampaign.campaignId;
+          campaignFile = path.join(campaignsDir, existingCampaignFile);
+          existingCampaign.callIds.push(...this.stats.createdCalls.map(c => c.callId));
+          existingCampaign.callMapping = { ...existingCampaign.callMapping, ...newCallMapping };
+          existingCampaign.totalCalls = existingCampaign.callIds.length;
+          existingCampaign.lastUpdated = new Date().toISOString();
+          campaignData = existingCampaign;
+          console.log(chalk.green(`\n✓ Updated existing campaign: ${campaignId}`));
+      } else {
+          campaignId = `campaign_${new Date().toISOString().replace(/[:.]/g, '-')}`;
+          campaignFile = path.join(campaignsDir, `${campaignId}.json`);
+          campaignData = {
+              campaignId,
+              csvFile: csvBaseName,
+              agentId: this.agentId,
+              totalCalls: this.stats.successful,
+              callIds: this.stats.createdCalls.map(c => c.callId),
+              callMapping: newCallMapping,
+              createdAt: new Date().toISOString()
+          };
+          console.log(chalk.green(`\n✓ Campaign saved: ${campaignId}`));
+      }
+
+      fs.writeFileSync(campaignFile, JSON.stringify(campaignData, null, 2));
+      const lastCampaignFile = path.join(campaignsDir, 'last-campaign.json');
+      fs.writeFileSync(lastCampaignFile, JSON.stringify(campaignData, null, 2));
+      console.log(chalk.gray(`  Monitor with: node blackbox-cli.js watch`));
+  }
+
+  _printSummary() {
+    console.log(chalk.blue('\n📊 Summary'));
+    console.log(chalk.blue('=========='));
+    console.log(`Total rows in CSV: ${this.stats.total}`);
+    if (this.stats.skipped > 0) console.log(chalk.gray(`○ Already enrolled: ${this.stats.skipped}`));
+    console.log(chalk.green(`✓ Successfully enrolled: ${this.stats.successful}`));
+    const validationErrors = this.stats.errors.filter(e => e.row && e.data);
+    console.log(chalk.red(`✗ Failed validation: ${validationErrors.length}`));
+    console.log(chalk.red(`✗ Failed API calls: ${this.stats.failed}`));
+
+    if (this.stats.createdCalls.length > 0) {
+      console.log(chalk.blue('\n📞 Sample Created Calls:'));
+      this.stats.createdCalls.slice(0, 3).forEach((call, index) => {
+        console.log(chalk.gray(`${index + 1}. Call ID: ${call.callId}, Endpoint: ${call.endpoint}`));
+      });
+    }
+
+    if (validationErrors.length > 0) {
+      console.log(chalk.red(`\n⚠️  Validation Errors (${validationErrors.length}):`));
+      validationErrors.slice(0, 5).forEach((err, index) => {
+        console.log(chalk.red(`${index + 1}. Row ${err.row}: ${err.data.endpoint} - ${err.error}`));
+      });
+      if (validationErrors.length > 5) console.log(chalk.red(`... and ${validationErrors.length - 5} more errors`));
+      console.log(chalk.yellow(`\n📝 Error messages have been added to the CSV file`));
+    }
+
+    const primary = computePrimaryApiFailure(this.stats.errors);
+    if (primary?.status) {
+      const hint = getFatalStatusMessage(primary.status, '');
+      if (hint) console.log(chalk.red(`Primary failure: ${primary.status} - ${hint}`));
+    }
+  }
+}
+
+module.exports = BatchCaller;
diff --git a/lib/campaign-watcher.js b/lib/campaign-watcher.js
index a9e20c6..1e2fa81 100644
--- a/lib/campaign-watcher.js
+++ b/lib/campaign-watcher.js
@@ -5,11 +5,15 @@ const chalk = require('chalk');
 const { fetchConcurrency } = require('./concurrency-service');
 const { calculateUtilizationPct, getConcurrencyLevel, getConcurrencyStatusMessage } = require('./concurrency-utils');
 
+const readline = require('readline');
+
 class CampaignWatcher {
-  constructor(campaign, apiUrl, apiKey) {
-    this.campaign = campaign;
-    this.apiUrl = apiUrl;
-    this.apiKey = apiKey;
+  constructor(campaignId, options) {
+    this.campaignId = campaignId;
+    this.apiUrl = options.apiUrl;
+    this.apiKey = options.apiKey;
+    this.refreshInterval = parseInt(options.refresh) * 1000;
+    this.campaign = null;
     this.callStates = new Map();
     this.activityFeed = [];
     this.isPaused = false;
@@ -648,6 +652,197 @@ class CampaignWatcher {
     }
     return this.campaign.agentId;
   }
+
+  async start() {
+    if (!this._loadCampaignData()) return;
+
+    console.log(chalk.yellow('Loading campaign data...'));
+    await this.fetchAgentDetails();
+    if (this.agentFatalExit) {
+        this._renderFatalError();
+        return;
+    }
+
+    await this.update();
+    this._render();
+
+    const isNonInteractive = Boolean(process.env.JEST_WORKER_ID || process.env.BLACKBOX_NON_INTERACTIVE === '1');
+    if (!isNonInteractive) {
+        this._setupKeyboardHandlers();
+        this.interval = setInterval(async () => {
+            if (!this.isPaused) {
+                await this.update();
+                this._render();
+                if (this.isComplete()) {
+                    console.log(chalk.green('\n\n✓ Campaign completed!'));
+                    clearInterval(this.interval);
+                    process.exit(0);
+                }
+            }
+        }, this.refreshInterval);
+    }
+  }
+
+  _loadCampaignData() {
+    const campaignsDir = path.join(process.cwd(), '.blackbox-campaigns');
+    let campaignFile;
+    if (this.campaignId) {
+      campaignFile = path.join(campaignsDir, `${this.campaignId}.json`);
+    } else {
+      campaignFile = path.join(campaignsDir, 'last-campaign.json');
+    }
+
+    if (!fs.existsSync(campaignFile)) {
+      console.error(chalk.red('✗ Error: Campaign not found. Run a batch-call first to create a campaign.'));
+      return false;
+    }
+
+    try {
+      this.campaign = JSON.parse(fs.readFileSync(campaignFile, 'utf8'));
+      return true;
+    } catch (error) {
+      console.error(chalk.red('✗ Error loading campaign:', error.message));
+      return false;
+    }
+  }
+
+  _setupKeyboardHandlers() {
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.on('keypress', async (str, key) => {
+      if (key.ctrl && key.name === 'c' || key.name === 'q') {
+        console.log(chalk.yellow('\n\nExiting...'));
+        process.exit(0);
+      }
+      switch (key.name) {
+        case 'p': this.togglePause(); break;
+        case 'r':
+          await this.updateConcurrency(true);
+          await this.update();
+          this._render();
+          break;
+        case 'e':
+          const filename = await this.exportResults();
+          console.log(chalk.green(`\n✓ Results exported to ${filename}`));
+          setTimeout(() => this._render(), 2000);
+          break;
+      }
+    });
+  }
+
+  _renderFatalError() {
+      if (this.agentFetchWarning) {
+        console.log(chalk.bgYellow.black(` ${this.agentFetchWarning} `));
+      }
+      const exitMsg = this.agentNotFound
+        ? 'Exiting: The specified agent does not exist. Please verify the agent ID in the BlackBox UI.'
+        : (this.agentFetchWarning && this.agentFetchWarning.includes('401')
+            ? 'Exiting: Invalid API key. Provide a valid key via --api-key or BLACKBOX_API_KEY.'
+            : (this.agentFetchWarning && this.agentFetchWarning.includes('403')
+                ? 'Exiting: Access forbidden for this API key on the requested resource.'
+                : 'Exiting due to unrecoverable error.'));
+      console.log(chalk.red(exitMsg));
+      process.exit(1);
+  }
+
+  _render() {
+    console.clear();
+    if (this.agentFetchWarning && !this.agentFatalExit) {
+        console.log(chalk.bgYellow.black(` ${this.agentFetchWarning} `));
+    }
+    this._renderHeader();
+    this._renderConcurrencyAlert();
+    this._renderScheduleStatus();
+    this._renderProgress();
+    this._renderStatusBreakdown();
+    this._renderActivityFeed();
+    this._renderControls();
+  }
+
+  _renderHeader() {
+    console.log(chalk.cyan('┌─ Campaign Monitor ──────────────────────────────────────────────────────┐'));
+    console.log(chalk.cyan('│') + ` Campaign: ${chalk.bold(this.campaign.campaignId)}`.padEnd(73) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ` Source: ${this.campaign.csvFile} (${this.campaign.totalCalls} calls)`.padEnd(73) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ` Agent: ${this.getAgentDisplayName()}`.padEnd(73) + chalk.cyan('│'));
+    console.log(chalk.cyan('│') + ` ${this.getConcurrencyDisplay()}`.padEnd(73) + chalk.cyan('│'));
+
+    const runtime = Math.floor((Date.now() - new Date(this.campaign.createdAt).getTime()) / 1000);
+    const hours = Math.floor(runtime / 3600);
+    const minutes = Math.floor((runtime % 3600) / 60);
+    const seconds = runtime % 60;
+    const runtimeStr = `${hours}h ${minutes}m ${seconds}s`;
+
+    console.log(chalk.cyan('│') + ` Runtime: ${runtimeStr} | Started: ${new Date(this.campaign.createdAt).toLocaleString()}`.padEnd(73) + chalk.cyan('│'));
+    console.log(chalk.cyan('└─────────────────────────────────────────────────────────────────────────┘'));
+  }
+
+  _renderConcurrencyAlert() {
+    const alertLines = this.getConcurrencyAlertLines();
+    if (alertLines.length > 0) {
+      console.log('');
+      alertLines.forEach(line => console.log(line));
+    }
+  }
+
+  _renderScheduleStatus() {
+    const scheduleStatus = this.isWithinSchedule();
+    if (!scheduleStatus.isOpen && this.agentSchedule) {
+      console.log('\n' + chalk.bgYellow.black(' ⚠️  OUTSIDE WORKING HOURS '));
+      console.log(chalk.yellow(`Calls paused until: ${scheduleStatus.nextWindow}`));
+      console.log(chalk.gray(`Agent schedule: ${this.formatScheduleDisplay()} ${this.agentTimezone}`));
+    }
+  }
+
+  _renderProgress() {
+    console.log('\n' + chalk.bold('Overall Progress'));
+    console.log('═'.repeat(75));
+    const progress = this.getProgress();
+    const bar = '█'.repeat(Math.floor((progress.percentage / 100) * 40)).padEnd(40, '░');
+    console.log(chalk.green(`${bar}  ${progress.percentage.toFixed(0)}% (${progress.completed}/${progress.total})`));
+    console.log(`Rate: ${this.getCallsPerMinute()} calls/min | Est. remaining: ${this.getEstimatedTimeRemaining()}`);
+  }
+
+  _renderStatusBreakdown() {
+    console.log('\n' + chalk.bold('Status Breakdown'));
+    console.log('═'.repeat(75));
+    const statuses = [
+      { name: 'Completed', key: 'completed', color: 'green' },
+      { name: 'Running', key: 'running', color: 'blue' },
+      { name: 'Queued', key: 'queued', color: 'yellow' },
+      { name: 'Failed', key: 'failed', color: 'red' }
+    ];
+    const maxCount = Math.max(...statuses.map(s => this.stats[s.key]));
+    statuses.forEach(s => {
+      const count = this.stats[s.key];
+      const bar = '█'.repeat(maxCount > 0 ? Math.floor((count / maxCount) * 20) : 0).padEnd(20);
+      const percentage = (this.campaign.totalCalls > 0 ? (count / this.campaign.totalCalls * 100) : 0).toFixed(0);
+      console.log(`${s.name.padEnd(10)} ${chalk[s.color](bar)} ${count.toString().padStart(6)} (${percentage}%)`);
+    });
+  }
+
+  _renderActivityFeed() {
+    console.log('\n' + chalk.bold('Live Feed (last 10 calls)'));
+    console.log('═'.repeat(75));
+    if (this.activityFeed.length === 0) {
+      console.log(chalk.gray('No activity yet...'));
+    } else {
+      this.activityFeed.slice().reverse().forEach(event => {
+        let line = `${chalk.gray(event.timestamp.toLocaleTimeString())}  `;
+        if (event.newStatus === 'completed') line += chalk.green(`✓ ${event.endpoint} completed (${event.durationSeconds}s)`);
+        else if (event.newStatus === 'running') line += chalk.blue(`● ${event.endpoint} started`);
+        else if (event.newStatus === 'failed') line += chalk.red(`✗ ${event.endpoint} failed`);
+        else line += chalk.gray(`○ ${event.endpoint} ${event.newStatus}`);
+        console.log(line);
+      });
+    }
+  }
+
+  _renderControls() {
+    console.log('\n' + chalk.gray('─'.repeat(75)));
+    console.log(chalk.gray('[R]efresh now  [P]ause  [E]xport results  [Q]uit'));
+    const pauseStatus = this.isPaused ? chalk.yellow('PAUSED') : chalk.green('ON');
+    console.log(chalk.gray(`Auto-refresh: ${pauseStatus} | Last update: ${new Date(this.stats.lastUpdateTime).toLocaleTimeString()}`));
+  }
 }
 
 module.exports = CampaignWatcher;
\ No newline at end of file
diff --git a/lib/utils.js b/lib/utils.js
new file mode 100644
index 0000000..0476960
--- /dev/null
+++ b/lib/utils.js
@@ -0,0 +1,105 @@
+const fs = require('fs');
+const path = require('path');
+
+function getFatalStatusMessage(status, agentId) {
+    switch (status) {
+        case 401:
+            return 'Invalid API key (401). Provide a valid key via --api-key or BLACKBOX_API_KEY.';
+        case 403:
+            return 'Forbidden (403). Your API key does not have access to this agent or resource.';
+        case 404:
+            return `Agent not found (404). Check the agent ID${agentId ? `: ${agentId}` : ''}.`;
+        default:
+            return '';
+    }
+}
+
+function computePrimaryApiFailure(errors) {
+    const apiErrors = (errors || []).filter(e => typeof e.status === 'number');
+    if (apiErrors.length === 0) return null;
+    const statusCounts = new Map();
+    for (const err of apiErrors) {
+        statusCounts.set(err.status, (statusCounts.get(err.status) || 0) + 1);
+    }
+    if (statusCounts.size !== 1) return null;
+    const [[status, count]] = Array.from(statusCounts.entries());
+    return { status, count };
+}
+
+function validatePhoneNumber(phoneNumber) {
+    const cleaned = phoneNumber.trim().replace(/[\s\-()]/g, '');
+    if (!cleaned.startsWith('+')) throw new Error('Phone number must start with + (e.g., +1234567890)');
+    if (!/^\+\d+$/.test(cleaned)) throw new Error('Phone number must contain only digits after the + sign');
+    const digitsOnly = cleaned.substring(1);
+    if (digitsOnly.length < 7 || digitsOnly.length > 15) throw new Error('Phone number must be between 7 and 15 digits (excluding +)');
+    return cleaned;
+}
+
+function writeProcessedCSV(csvFile, allRows) {
+    if (allRows.length === 0) return;
+    const firstRow = allRows[0];
+    const headers = Object.keys(firstRow.data);
+    if (!headers.includes('error_message')) {
+        headers.push('error_message');
+    }
+    let csvContent = headers.map(h => `"${h}"`).join(',') + '\n';
+    allRows.forEach(row => {
+        const values = headers.map(header => {
+            if (header === 'error_message') return `"${row.error || ''}"`;
+            const value = row.data[header] || '';
+            return `"${String(value).replace(/"/g, '""')}"`;
+        });
+        csvContent += values.join(',') + '\n';
+    });
+    fs.writeFileSync(csvFile, csvContent);
+    return csvFile;
+}
+
+function loadPreviousCampaignEndpoints(csvFile) {
+    const campaignsDir = path.join(process.cwd(), '.blackbox-campaigns');
+    const csvBaseName = path.basename(csvFile);
+    const enrolledEndpoints = new Set();
+    if (!fs.existsSync(campaignsDir)) return enrolledEndpoints;
+    const campaignFiles = fs.readdirSync(campaignsDir).filter(f => f.endsWith('.json') && f !== 'last-campaign.json');
+    for (const campaignFile of campaignFiles) {
+        try {
+            const campaignData = JSON.parse(fs.readFileSync(path.join(campaignsDir, campaignFile), 'utf8'));
+            if (campaignData.csvFile === csvBaseName && campaignData.callMapping) {
+                Object.values(campaignData.callMapping).forEach(call => enrolledEndpoints.add(call.endpoint));
+            }
+        } catch (error) { continue; }
+    }
+    return enrolledEndpoints;
+}
+
+function getSystemTimezone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch (e) { return 'UTC'; }
+}
+
+function parseDeadline(deadlineStr) {
+    if (!deadlineStr) {
+        const deadline = new Date();
+        deadline.setHours(deadline.getHours() + 24);
+        return deadline.toISOString();
+    }
+    const deadline = new Date(deadlineStr);
+    if (isNaN(deadline.getTime())) throw new Error(`Invalid deadline format: ${deadlineStr}`);
+    const now = new Date();
+    const sevenDaysFromNow = new Date();
+    sevenDaysFromNow.setDate(sevenDaysFromNow.getDate() + 7);
+    if (deadline < now) throw new Error(`Deadline is in the past: ${deadlineStr}`);
+    if (deadline > sevenDaysFromNow) throw new Error(`Deadline is more than 7 days in future: ${deadlineStr}`);
+    return deadline.toISOString();
+}
+
+module.exports = {
+    getFatalStatusMessage,
+    computePrimaryApiFailure,
+    validatePhoneNumber,
+    writeProcessedCSV,
+    loadPreviousCampaignEndpoints,
+    getSystemTimezone,
+    parseDeadline,
+};