myaidev-method 0.2.24-1 → 0.2.24-2

package/src/lib/content-coordinator.js

@@ -0,0 +1,2562 @@
+/**
+ * Content Production Coordinator
+ *
+ * State machine implementation for coordinating content verification and publishing.
+ * Provides checkpoint/resume capability, error isolation, progress tracking,
+ * multi-platform publishing, analytics, webhooks, and queue management.
+ *
+ * @module content-coordinator
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import https from 'https';
+import http from 'http';
+import os from 'os';
+
+/**
+ * Workflow phases for the content production coordinator
+ */
+const PHASES = {
+  INITIALIZE: 'initialize',
+  VERIFY: 'verify',
+  CATEGORIZE: 'categorize',
+  REPORT: 'report',
+  NOTIFY: 'notify',
+  PUBLISH: 'publish',
+  COMPLETE: 'complete'
+};
+
+/**
+ * Content item status values
+ */
+const ITEM_STATUS = {
+  PENDING: 'pending',
+  VERIFYING: 'verifying',
+  VERIFIED: 'verified',
+  READY: 'ready',
+  NEEDS_REVIEW: 'needs_review',
+  PUBLISHING: 'publishing',
+  PUBLISHED: 'published',
+  FAILED: 'failed',
+  SKIPPED: 'skipped'
+};
+
+/**
+ * Redundancy score thresholds
+ */
+const REDUNDANCY_THRESHOLDS = {
+  MINIMAL: 'minimal',
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high'
+};
+
+/**
+ * Supported publishing platforms
+ */
+const PLATFORMS = {
+  WORDPRESS: 'wordpress',
+  PAYLOADCMS: 'payloadcms',
+  STATIC: 'static',
+  DOCUSAURUS: 'docusaurus',
+  MINTLIFY: 'mintlify',
+  ASTRO: 'astro'
+};
+
+/**
+ * Default configuration for the coordinator
+ */
+const DEFAULT_CONFIG = {
+  concurrency: 3,
+  retryAttempts: 2,
+  retryDelay: 1000,
+  checkpointInterval: 5000,
+  stateFileName: '.content-coordinator-state.json',
+  queueFileName: '.content-queue.json',
+  outputDir: '.',
+  dryRun: false,
+  force: false,
+  verbose: false,
+  // Content rules
+  contentRulesPath: null,
+  // Webhooks
+  webhookUrl: null,
+  webhookEvents: ['complete', 'error'],
+  // Analytics
+  enableAnalytics: true,
+  // Platform
+  defaultPlatform: PLATFORMS.WORDPRESS,
+  // Cron/Scheduling
+  cronMode: false,
+  lockFileName: '.content-coordinator.lock',
+  lastRunFileName: '.content-coordinator-lastrun.json',
+  minRunInterval: 0, // Minimum seconds between runs (0 = no limit)
+  quietMode: false, // Suppress non-error output for cron
+  // WordPress Scheduling
+  useWordPressScheduling: true, // Use WP native scheduling for future posts
+  defaultPublishDelay: 0, // Hours to delay publication (0 = immediate)
+  publishSpreadInterval: 0 // Hours between scheduled posts (0 = no spreading)
+};
+
+/**
+ * ContentRulesManager - Handles loading and applying content rules
+ */
+class ContentRulesManager {
+  constructor(rulesPath) {
+    this.rulesPath = rulesPath;
+    this.rules = null;
+    this.loaded = false;
+  }
+
+  /**
+   * Load content rules from file
+   * @returns {Promise<Object|null>} Parsed rules or null
+   */
+  async load() {
+    if (!this.rulesPath) return null;
+
+    try {
+      const content = await fs.readFile(this.rulesPath, 'utf8');
+      this.rules = this.parseContentRules(content);
+      this.loaded = true;
+      return this.rules;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error('[ContentRules] Error loading rules:', err.message);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Parse content-rules.md file
+   * @param {string} content - Raw file content
+   * @returns {Object} Parsed rules
+   */
+  parseContentRules(content) {
+    const rules = {
+      brandIdentity: {},
+      voiceTone: {},
+      writingStyle: {},
+      seoGuidelines: {},
+      formatting: {},
+      contentBoundaries: {}
+    };
+
+    // Extract sections using markdown headers
+    const sections = content.split(/^## /m).slice(1);
+
+    for (const section of sections) {
+      const lines = section.split('\n');
+      const header = lines[0].trim().toLowerCase();
+      const body = lines.slice(1).join('\n').trim();
+
+      if (header.includes('brand') || header.includes('identity')) {
+        rules.brandIdentity = this.parseSection(body);
+      } else if (header.includes('voice') || header.includes('tone')) {
+        rules.voiceTone = this.parseSection(body);
+      } else if (header.includes('writing') || header.includes('style')) {
+        rules.writingStyle = this.parseSection(body);
+      } else if (header.includes('seo')) {
+        rules.seoGuidelines = this.parseSection(body);
+      } else if (header.includes('format')) {
+        rules.formatting = this.parseSection(body);
+      } else if (header.includes('boundar') || header.includes('avoid')) {
+        rules.contentBoundaries = this.parseSection(body);
+      }
+    }
+
+    return rules;
+  }
+
+  /**
+   * Parse a section into key-value pairs
+   * @param {string} body - Section body
+   * @returns {Object} Parsed key-values
+   */
+  parseSection(body) {
+    const result = {};
+    const lines = body.split('\n');
+
+    for (const line of lines) {
+      // Parse list items: - **Key**: Value
+      const match = line.match(/^[-*]\s*\*\*([^*]+)\*\*:\s*(.+)$/);
+      if (match) {
+        const key = match[1].trim().toLowerCase().replace(/\s+/g, '_');
+        result[key] = match[2].trim();
+      }
+      // Parse simple list items: - Value
+      const simpleMatch = line.match(/^[-*]\s+(.+)$/);
+      if (simpleMatch && !match) {
+        if (!result.items) result.items = [];
+        result.items.push(simpleMatch[1].trim());
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get rules for verification context
+   * @returns {Object} Rules relevant for verification
+   */
+  getVerificationContext() {
+    if (!this.rules) return null;
+
+    return {
+      brandVoice: this.rules.voiceTone,
+      writingStyle: this.rules.writingStyle,
+      contentBoundaries: this.rules.contentBoundaries,
+      checkBrandAlignment: true
+    };
+  }
+
+  /**
+   * Get rules for publishing context
+   * @returns {Object} Rules relevant for publishing
+   */
+  getPublishingContext() {
+    if (!this.rules) return null;
+
+    return {
+      brandIdentity: this.rules.brandIdentity,
+      seoGuidelines: this.rules.seoGuidelines,
+      formatting: this.rules.formatting
+    };
+  }
+}
+
+/**
+ * AnalyticsTracker - Tracks timing, success rates, and quality metrics
+ */
+class AnalyticsTracker {
+  constructor() {
+    this.metrics = {
+      workflow: {
+        startTime: null,
+        endTime: null,
+        duration: null,
+        phases: {}
+      },
+      items: {
+        total: 0,
+        verified: 0,
+        published: 0,
+        failed: 0,
+        skipped: 0
+      },
+      performance: {
+        avgVerificationTime: 0,
+        avgPublishTime: 0,
+        totalVerificationTime: 0,
+        totalPublishTime: 0
+      },
+      quality: {
+        avgRedundancyScore: 0,
+        avgUniquenessScore: 0,
+        contentQualityTrend: []
+      },
+      errors: []
+    };
+    this.phaseTimers = {};
+  }
+
+  /**
+   * Start workflow tracking
+   */
+  startWorkflow() {
+    this.metrics.workflow.startTime = Date.now();
+  }
+
+  /**
+   * End workflow tracking
+   */
+  endWorkflow() {
+    this.metrics.workflow.endTime = Date.now();
+    this.metrics.workflow.duration = this.metrics.workflow.endTime - this.metrics.workflow.startTime;
+  }
+
+  /**
+   * Start phase timing
+   * @param {string} phase - Phase name
+   */
+  startPhase(phase) {
+    this.phaseTimers[phase] = Date.now();
+  }
+
+  /**
+   * End phase timing
+   * @param {string} phase - Phase name
+   */
+  endPhase(phase) {
+    if (this.phaseTimers[phase]) {
+      this.metrics.workflow.phases[phase] = {
+        duration: Date.now() - this.phaseTimers[phase],
+        completedAt: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Track item verification
+   * @param {Object} item - Content item
+   * @param {number} duration - Verification duration in ms
+   */
+  trackVerification(item, duration) {
+    this.metrics.items.verified++;
+    this.metrics.performance.totalVerificationTime += duration;
+    this.metrics.performance.avgVerificationTime =
+      this.metrics.performance.totalVerificationTime / this.metrics.items.verified;
+
+    // Track quality metrics
+    if (item.verification) {
+      const scores = { minimal: 1, low: 2, medium: 3, high: 4 };
+      const score = (item.verification.redundancyScore || '').toLowerCase();
+      if (scores[score]) {
+        this.metrics.quality.contentQualityTrend.push({
+          item: item.metadata.title,
+          redundancyScore: scores[score],
+          uniquenessScore: item.verification.uniquenessScore || 0,
+          timestamp: new Date().toISOString()
+        });
+
+        // Update averages
+        const trend = this.metrics.quality.contentQualityTrend;
+        this.metrics.quality.avgRedundancyScore =
+          trend.reduce((sum, t) => sum + t.redundancyScore, 0) / trend.length;
+        this.metrics.quality.avgUniquenessScore =
+          trend.reduce((sum, t) => sum + (t.uniquenessScore || 0), 0) / trend.length;
+      }
+    }
+  }
+
+  /**
+   * Track item publishing
+   * @param {Object} item - Content item
+   * @param {number} duration - Publishing duration in ms
+   */
+  trackPublishing(item, duration) {
+    this.metrics.items.published++;
+    this.metrics.performance.totalPublishTime += duration;
+    this.metrics.performance.avgPublishTime =
+      this.metrics.performance.totalPublishTime / this.metrics.items.published;
+  }
+
+  /**
+   * Track error
+   * @param {Object} item - Content item
+   * @param {Error} error - Error object
+   * @param {string} phase - Phase where error occurred
+   */
+  trackError(item, error, phase) {
+    this.metrics.items.failed++;
+    this.metrics.errors.push({
+      item: item.metadata?.title || 'Unknown',
+      error: error.message,
+      phase,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Set total items count
+   * @param {number} count - Total items
+   */
+  setTotalItems(count) {
+    this.metrics.items.total = count;
+  }
+
+  /**
+   * Get analytics summary
+   * @returns {Object} Analytics summary
+   */
+  getSummary() {
+    const successRate = this.metrics.items.total > 0
+      ? ((this.metrics.items.published / this.metrics.items.total) * 100).toFixed(1)
+      : 0;
+
+    return {
+      ...this.metrics,
+      summary: {
+        successRate: `${successRate}%`,
+        totalDuration: this.formatDuration(this.metrics.workflow.duration),
+        avgVerificationTime: this.formatDuration(this.metrics.performance.avgVerificationTime),
+        avgPublishTime: this.formatDuration(this.metrics.performance.avgPublishTime),
+        avgQualityScore: (5 - this.metrics.quality.avgRedundancyScore).toFixed(2) + '/4'
+      }
+    };
+  }
+
+  /**
+   * Format duration to human-readable string
+   * @param {number} ms - Duration in milliseconds
+   * @returns {string} Formatted duration
+   */
+  formatDuration(ms) {
+    if (!ms) return 'N/A';
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+  }
+}
+
+/**
+ * WebhookNotifier - Sends notifications to external systems
+ */
+class WebhookNotifier {
+  constructor(config) {
+    this.url = config.webhookUrl;
+    this.events = config.webhookEvents || ['complete', 'error'];
+    this.enabled = !!this.url;
+  }
+
+  /**
+   * Send webhook notification
+   * @param {string} event - Event type
+   * @param {Object} payload - Event payload
+   * @returns {Promise<boolean>} Success status
+   */
+  async notify(event, payload) {
+    if (!this.enabled || !this.events.includes(event)) {
+      return false;
+    }
+
+    const data = JSON.stringify({
+      event,
+      timestamp: new Date().toISOString(),
+      payload
+    });
+
+    return new Promise((resolve) => {
+      try {
+        const urlObj = new URL(this.url);
+        const options = {
+          hostname: urlObj.hostname,
+          port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+          path: urlObj.pathname + urlObj.search,
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(data),
+            'User-Agent': 'ContentCoordinator/1.0'
+          }
+        };
+
+        const protocol = urlObj.protocol === 'https:' ? https : http;
+        const req = protocol.request(options, (res) => {
+          resolve(res.statusCode >= 200 && res.statusCode < 300);
+        });
+
+        req.on('error', (err) => {
+          console.error('[Webhook] Error:', err.message);
+          resolve(false);
+        });
+
+        req.setTimeout(5000, () => {
+          req.destroy();
+          resolve(false);
+        });
+
+        req.write(data);
+        req.end();
+      } catch (err) {
+        console.error('[Webhook] Error:', err.message);
+        resolve(false);
+      }
+    });
+  }
+
+  /**
+   * Notify workflow start
+   * @param {Object} info - Workflow info
+   */
+  async notifyStart(info) {
+    await this.notify('start', info);
+  }
+
+  /**
+   * Notify workflow complete
+   * @param {Object} results - Final results
+   */
+  async notifyComplete(results) {
+    await this.notify('complete', results);
+  }
+
+  /**
+   * Notify error
+   * @param {Object} error - Error info
+   */
+  async notifyError(error) {
+    await this.notify('error', error);
+  }
+
+  /**
+   * Notify item published
+   * @param {Object} item - Published item info
+   */
+  async notifyPublished(item) {
+    await this.notify('published', item);
+  }
+}
+
+/**
+ * QueueManager - Manages persistent content queue
+ */
+class QueueManager {
+  constructor(queuePath) {
+    this.queuePath = queuePath;
+    this.queue = {
+      version: '1.0',
+      created: null,
+      updated: null,
+      items: []
+    };
+  }
+
+  /**
+   * Load queue from file
+   * @returns {Promise<Object>} Queue data
+   */
+  async load() {
+    try {
+      const data = await fs.readFile(this.queuePath, 'utf8');
+      this.queue = JSON.parse(data);
+      return this.queue;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error('[QueueManager] Error loading queue:', err.message);
+      }
+      this.queue.created = new Date().toISOString();
+      return this.queue;
+    }
+  }
+
+  /**
+   * Save queue to file
+   * @returns {Promise<void>}
+   */
+  async save() {
+    this.queue.updated = new Date().toISOString();
+    await fs.writeFile(this.queuePath, JSON.stringify(this.queue, null, 2));
+  }
+
+  /**
+   * Add item to queue
+   * @param {Object} item - Item to add
+   * @returns {Object} Added item with ID
+   */
+  async addItem(item) {
+    const queueItem = {
+      id: `item-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      addedAt: new Date().toISOString(),
+      status: 'pending',
+      priority: item.priority || 'normal',
+      filePath: item.filePath,
+      metadata: item.metadata || {},
+      ...item
+    };
+
+    this.queue.items.push(queueItem);
+    await this.save();
+    return queueItem;
+  }
+
+  /**
+   * Remove item from queue
+   * @param {string} id - Item ID to remove
+   * @returns {boolean} Whether item was removed
+   */
+  async removeItem(id) {
+    const index = this.queue.items.findIndex(item => item.id === id);
+    if (index === -1) return false;
+
+    this.queue.items.splice(index, 1);
+    await this.save();
+    return true;
+  }
+
+  /**
+   * Update item status
+   * @param {string} id - Item ID
+   * @param {string} status - New status
+   * @param {Object} [extra] - Additional data to merge
+   */
+  async updateItemStatus(id, status, extra = {}) {
+    const item = this.queue.items.find(i => i.id === id);
+    if (item) {
+      item.status = status;
+      item.updatedAt = new Date().toISOString();
+      Object.assign(item, extra);
+      await this.save();
+    }
+  }
+
+  /**
+   * Get pending items sorted by priority
+   * @returns {Object[]} Pending items
+   */
+  getPendingItems() {
+    const priorityOrder = { high: 0, normal: 1, low: 2 };
+    return this.queue.items
+      .filter(item => item.status === 'pending')
+      .sort((a, b) => {
+        const pA = priorityOrder[a.priority] ?? 1;
+        const pB = priorityOrder[b.priority] ?? 1;
+        if (pA !== pB) return pA - pB;
+        return new Date(a.addedAt) - new Date(b.addedAt);
+      });
+  }
+
+  /**
+   * Get queue statistics
+   * @returns {Object} Queue stats
+   */
+  getStats() {
+    const stats = {
+      total: this.queue.items.length,
+      pending: 0,
+      processing: 0,
+      completed: 0,
+      failed: 0,
+      byPriority: { high: 0, normal: 0, low: 0 }
+    };
+
+    for (const item of this.queue.items) {
+      if (item.status === 'pending') stats.pending++;
+      else if (item.status === 'processing') stats.processing++;
+      else if (item.status === 'completed' || item.status === 'published') stats.completed++;
+      else if (item.status === 'failed') stats.failed++;
+
+      if (stats.byPriority[item.priority] !== undefined) {
+        stats.byPriority[item.priority]++;
+      }
+    }
+
+    return stats;
+  }
+
+  /**
+   * Clear completed items from queue
+   * @returns {number} Number of items cleared
+   */
+  async clearCompleted() {
+    const before = this.queue.items.length;
+    this.queue.items = this.queue.items.filter(
+      item => !['completed', 'published'].includes(item.status)
+    );
+    await this.save();
+    return before - this.queue.items.length;
+  }
+}
+
+/**
+ * PlatformPublisher - Abstract publishing interface for multiple platforms
+ */
+class PlatformPublisher {
+  constructor(config) {
+    this.config = config;
+    this.platforms = new Map();
+    this.initializePlatforms();
+  }
+
+  /**
+   * Initialize platform handlers
+   */
+  initializePlatforms() {
+    // WordPress publisher
+    this.platforms.set(PLATFORMS.WORDPRESS, {
+      name: 'WordPress',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.WORDPRESS,
+          endpoint: 'wp-json/wp/v2/posts'
+        });
+      },
+      validateConfig: () => {
+        return !!(process.env.WORDPRESS_URL && process.env.WORDPRESS_APP_PASSWORD);
+      }
+    });
+
+    // PayloadCMS publisher
+    this.platforms.set(PLATFORMS.PAYLOADCMS, {
+      name: 'PayloadCMS',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.PAYLOADCMS,
+          endpoint: 'api/posts'
+        });
+      },
+      validateConfig: () => {
+        return !!(process.env.PAYLOADCMS_URL && process.env.PAYLOADCMS_EMAIL);
+      }
+    });
+
+    // Static site generator (writes to file)
+    this.platforms.set(PLATFORMS.STATIC, {
+      name: 'Static',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.STATIC,
+          outputDir: this.config.staticOutputDir || './content'
+        });
+      },
+      validateConfig: () => true
+    });
+
+    // Docusaurus
+    this.platforms.set(PLATFORMS.DOCUSAURUS, {
+      name: 'Docusaurus',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.DOCUSAURUS,
+          outputDir: this.config.docusaurusDir || './docs'
+        });
+      },
+      validateConfig: () => true
+    });
+
+    // Mintlify
+    this.platforms.set(PLATFORMS.MINTLIFY, {
+      name: 'Mintlify',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.MINTLIFY,
+          outputDir: this.config.mintlifyDir || './docs'
+        });
+      },
+      validateConfig: () => true
+    });
+
+    // Astro
+    this.platforms.set(PLATFORMS.ASTRO, {
+      name: 'Astro',
+      publish: async (item, publishFn) => {
+        return publishFn(item, {
+          platform: PLATFORMS.ASTRO,
+          outputDir: this.config.astroDir || './src/content'
+        });
+      },
+      validateConfig: () => true
+    });
+  }
+
+  /**
+   * Get publisher for platform
+   * @param {string} platform - Platform name
+   * @returns {Object|null} Platform publisher
+   */
+  getPublisher(platform) {
+    return this.platforms.get(platform) || this.platforms.get(this.config.defaultPlatform);
+  }
+
+  /**
+   * Validate platform configuration
+   * @param {string} platform - Platform name
+   * @returns {boolean} Whether config is valid
+   */
+  validatePlatform(platform) {
+    const publisher = this.getPublisher(platform);
+    return publisher ? publisher.validateConfig() : false;
+  }
+
+  /**
+   * Get available platforms
+   * @returns {string[]} List of configured platforms
+   */
+  getAvailablePlatforms() {
+    const available = [];
+    for (const [name, publisher] of this.platforms) {
+      if (publisher.validateConfig()) {
+        available.push(name);
+      }
+    }
+    return available;
+  }
+}
+
+/**
+ * CronHelper - Manages cron-safe execution and crontab integration
+ *
+ * Makes the coordinator safe to run from Linux crontab by:
+ * - Using lock files to prevent concurrent runs
+ * - Tracking last run times
+ * - Providing quiet mode for cron output
+ * - Generating crontab entry suggestions
+ */
+class CronHelper {
+  constructor(config) {
+    this.config = config;
+    this.lockPath = path.join(config.outputDir, config.lockFileName);
+    this.lastRunPath = path.join(config.outputDir, config.lastRunFileName);
+    this.lockFd = null;
+  }
+
+  /**
+   * Acquire exclusive lock to prevent concurrent runs
+   * @returns {Promise<boolean>} Whether lock was acquired
+   */
+  async acquireLock() {
+    try {
+      // Check if lock file exists and is stale
+      try {
+        const lockData = await fs.readFile(this.lockPath, 'utf8');
+        const lock = JSON.parse(lockData);
+
+        // Check if lock is stale (older than 1 hour)
+        const lockAge = Date.now() - new Date(lock.timestamp).getTime();
+        const maxAge = 60 * 60 * 1000; // 1 hour
+
+        if (lockAge > maxAge) {
+          console.error('[CronHelper] Stale lock detected, removing...');
+          await fs.unlink(this.lockPath);
+        } else {
+          // Lock is held by another process
+          if (!this.config.quietMode) {
+            console.log(`[CronHelper] Lock held by PID ${lock.pid} since ${lock.timestamp}`);
+          }
+          return false;
+        }
+      } catch (err) {
+        // Lock file doesn't exist, we can proceed
+        if (err.code !== 'ENOENT') throw err;
+      }
+
+      // Create lock file
+      const lockData = {
+        pid: process.pid,
+        timestamp: new Date().toISOString(),
+        hostname: os.hostname()
+      };
+
+      await fs.writeFile(this.lockPath, JSON.stringify(lockData, null, 2), { flag: 'wx' });
+      return true;
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        // Another process created the lock first
+        return false;
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Release the lock
+   * @returns {Promise<void>}
+   */
+  async releaseLock() {
+    try {
+      await fs.unlink(this.lockPath);
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error('[CronHelper] Error releasing lock:', err.message);
+      }
+    }
+  }
+
+  /**
+   * Check if minimum run interval has passed
+   * @returns {Promise<{canRun: boolean, nextRunTime: Date|null, lastRun: Date|null}>}
+   */
+  async checkRunInterval() {
+    if (this.config.minRunInterval <= 0) {
+      return { canRun: true, nextRunTime: null, lastRun: null };
+    }
+
+    try {
+      const data = await fs.readFile(this.lastRunPath, 'utf8');
+      const lastRunInfo = JSON.parse(data);
+      const lastRun = new Date(lastRunInfo.timestamp);
+      const elapsed = (Date.now() - lastRun.getTime()) / 1000;
+
+      if (elapsed < this.config.minRunInterval) {
+        const nextRunTime = new Date(lastRun.getTime() + this.config.minRunInterval * 1000);
+        return { canRun: false, nextRunTime, lastRun };
+      }
+
+      return { canRun: true, nextRunTime: null, lastRun };
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        // No last run file, first run
+        return { canRun: true, nextRunTime: null, lastRun: null };
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Record successful run
+   * @param {Object} results - Run results summary
+   * @returns {Promise<void>}
+   */
+  async recordRun(results) {
+    const runInfo = {
+      timestamp: new Date().toISOString(),
+      pid: process.pid,
+      results: {
+        total: results.stats?.totalItems || 0,
+        published: results.stats?.published || 0,
+        failed: results.stats?.failed || 0,
+        duration: results.duration
+      }
+    };
+
+    await fs.writeFile(this.lastRunPath, JSON.stringify(runInfo, null, 2));
+  }
+
+  /**
+   * Get last run information
+   * @returns {Promise<Object|null>}
+   */
+  async getLastRun() {
+    try {
+      const data = await fs.readFile(this.lastRunPath, 'utf8');
+      return JSON.parse(data);
+    } catch (err) {
+      if (err.code === 'ENOENT') return null;
+      throw err;
+    }
+  }
+
+  /**
+   * Generate crontab entry for scheduling
+   * @param {Object} options - Scheduling options
+   * @returns {string} Crontab entry
+   */
+  generateCrontabEntry(options = {}) {
+    const {
+      schedule = '0 */6 * * *', // Default: every 6 hours
+      workDir = process.cwd(),
+      contentDir = './content-queue',
+      logFile = '/var/log/content-coordinator.log',
+      user = process.env.USER || 'ubuntu',
+      extraFlags = ''
+    } = options;
+
+    const command = `cd ${workDir} && /usr/bin/npx myaidev-method coordinate-content ${contentDir} --cron --force ${extraFlags}`.trim();
+
+    return `# Content Coordinator - Automated publishing
+# Schedule: ${this.describeCronSchedule(schedule)}
+# Added: ${new Date().toISOString()}
+${schedule} ${user} ${command} >> ${logFile} 2>&1
+
+# Alternative with flock for extra safety:
+# ${schedule} ${user} /usr/bin/flock -n /tmp/content-coordinator.lock ${command} >> ${logFile} 2>&1
+`;
+  }
+
+  /**
+   * Describe cron schedule in human-readable format
+   * @param {string} schedule - Cron schedule expression
+   * @returns {string} Human-readable description
+   */
+  describeCronSchedule(schedule) {
+    const parts = schedule.split(' ');
+    if (parts.length !== 5) return schedule;
+
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+
+    // Common patterns
+    if (schedule === '0 * * * *') return 'Every hour';
+    if (schedule === '*/15 * * * *') return 'Every 15 minutes';
+    if (schedule === '*/30 * * * *') return 'Every 30 minutes';
+    if (schedule === '0 */2 * * *') return 'Every 2 hours';
+    if (schedule === '0 */6 * * *') return 'Every 6 hours';
+    if (schedule === '0 */12 * * *') return 'Every 12 hours';
+    if (schedule === '0 0 * * *') return 'Daily at midnight';
+    if (schedule === '0 9 * * *') return 'Daily at 9:00 AM';
+    if (schedule === '0 9 * * 1-5') return 'Weekdays at 9:00 AM';
+    if (schedule === '0 0 * * 0') return 'Weekly on Sunday at midnight';
+    if (schedule === '0 0 1 * *') return 'Monthly on the 1st at midnight';
+
+    return schedule;
+  }
+
+  /**
+   * Get suggested cron schedules for different use cases
+   * @returns {Object[]} Array of schedule suggestions
+   */
+  getSuggestedSchedules() {
+    return [
+      {
+        name: 'High frequency',
+        schedule: '*/30 * * * *',
+        description: 'Every 30 minutes - for time-sensitive content'
+      },
+      {
+        name: 'Regular',
+        schedule: '0 */6 * * *',
+        description: 'Every 6 hours - balanced approach'
+      },
+      {
+        name: 'Daily morning',
+        schedule: '0 9 * * *',
+        description: 'Daily at 9:00 AM - publish during business hours'
+      },
+      {
+        name: 'Weekdays only',
+        schedule: '0 9 * * 1-5',
+        description: 'Weekdays at 9:00 AM - avoid weekend publishing'
+      },
+      {
+        name: 'Twice daily',
+        schedule: '0 9,17 * * *',
+        description: '9:00 AM and 5:00 PM - morning and evening'
+      },
+      {
+        name: 'Weekly',
+        schedule: '0 9 * * 1',
+        description: 'Every Monday at 9:00 AM - weekly content drops'
+      }
+    ];
+  }
+
+  /**
+   * Validate cron expression
+   * @param {string} expression - Cron expression to validate
+   * @returns {{valid: boolean, error?: string}}
+   */
+  validateCronExpression(expression) {
+    const parts = expression.trim().split(/\s+/);
+
+    if (parts.length !== 5) {
+      return {
+        valid: false,
+        error: `Expected 5 fields (minute hour day month weekday), got ${parts.length}`
+      };
+    }
+
+    const ranges = [
+      { name: 'minute', min: 0, max: 59 },
+      { name: 'hour', min: 0, max: 23 },
+      { name: 'day of month', min: 1, max: 31 },
+      { name: 'month', min: 1, max: 12 },
+      { name: 'day of week', min: 0, max: 7 }
+    ];
+
+    for (let i = 0; i < 5; i++) {
+      const part = parts[i];
+      const range = ranges[i];
+
+      // Skip wildcards
+      if (part === '*') continue;
+
+      // Check step values (*/n)
+      if (part.startsWith('*/')) {
+        const step = parseInt(part.slice(2), 10);
+        if (isNaN(step) || step < 1) {
+          return { valid: false, error: `Invalid step value in ${range.name}: ${part}` };
+        }
+        continue;
+      }
+
+      // Check ranges (n-m)
+      if (part.includes('-')) {
+        const [start, end] = part.split('-').map(n => parseInt(n, 10));
+        if (isNaN(start) || isNaN(end) || start < range.min || end > range.max || start > end) {
+          return { valid: false, error: `Invalid range in ${range.name}: ${part}` };
+        }
+        continue;
+      }
+
+      // Check lists (n,m,...)
+      if (part.includes(',')) {
+        const values = part.split(',').map(n => parseInt(n, 10));
+        for (const val of values) {
+          if (isNaN(val) || val < range.min || val > range.max) {
+            return { valid: false, error: `Invalid value in ${range.name} list: ${val}` };
+          }
+        }
+        continue;
+      }
+
+      // Check single value
+      const val = parseInt(part, 10);
+      if (isNaN(val) || val < range.min || val > range.max) {
+        return { valid: false, error: `Invalid ${range.name}: ${part} (must be ${range.min}-${range.max})` };
+      }
+    }
+
+    return { valid: true };
+  }
+}
+
+/**
+ * ScheduleManager - Manages WordPress native scheduling and content spreading
+ *
+ * Uses WordPress REST API to schedule posts for future publication:
+ * - status: 'future' with date parameter
+ * - Spreads posts across time to avoid publishing everything at once
+ * - Respects publish_date from content front matter
+ */
+class ScheduleManager {
+  constructor(config) {
+    this.config = config;
+    this.scheduledPosts = [];
+  }
+
+  /**
+   * Calculate publish date for an item
+   * @param {Object} item - Content item
+   * @param {number} index - Item index in batch
+   * @param {number} totalItems - Total items in batch
+   * @returns {Date} Scheduled publish date
+   */
+  calculatePublishDate(item, index, totalItems) {
+    // Check if item has explicit publish date in front matter
+    if (item.metadata.publish_date || item.metadata.scheduled_date) {
+      const explicitDate = new Date(item.metadata.publish_date || item.metadata.scheduled_date);
+      if (!isNaN(explicitDate.getTime())) {
+        return explicitDate;
+      }
+    }
+
+    // If publish immediately
+    if (this.config.defaultPublishDelay === 0 && this.config.publishSpreadInterval === 0) {
+      return new Date(); // Now
+    }
+
+    // Calculate base time (now + default delay)
+    const baseTime = new Date();
+    baseTime.setHours(baseTime.getHours() + this.config.defaultPublishDelay);
+
+    // Apply spread interval if configured
+    if (this.config.publishSpreadInterval > 0) {
+      baseTime.setHours(baseTime.getHours() + (index * this.config.publishSpreadInterval));
+    }
+
+    return baseTime;
+  }
+
+  /**
+   * Get WordPress post status based on publish date
+   * @param {Date} publishDate - Scheduled publish date
+   * @returns {string} WordPress post status ('publish' or 'future')
+   */
+  getWordPressStatus(publishDate) {
+    const now = new Date();
+    // If publish date is in the future (more than 1 minute from now), use 'future' status
+    if (publishDate.getTime() > now.getTime() + 60000) {
+      return 'future';
+    }
+    return 'publish';
+  }
+
+  /**
+   * Format date for WordPress REST API (ISO 8601)
+   * @param {Date} date - Date to format
+   * @returns {string} ISO 8601 formatted date
+   */
+  formatForWordPress(date) {
+    return date.toISOString();
+  }
+
+  /**
+   * Get scheduling context for publishing
+   * @param {Object} item - Content item
+   * @param {number} index - Item index
+   * @param {number} totalItems - Total items
+   * @returns {Object} Scheduling context for publisher
+   */
+  getSchedulingContext(item, index, totalItems) {
+    const publishDate = this.calculatePublishDate(item, index, totalItems);
+    const status = this.getWordPressStatus(publishDate);
+
+    return {
+      useWordPressScheduling: this.config.useWordPressScheduling,
+      publishDate: this.formatForWordPress(publishDate),
+      status: status,
+      isScheduled: status === 'future',
+      scheduledFor: publishDate.toLocaleString()
+    };
+  }
+
+  /**
+   * Track scheduled post
+   * @param {Object} item - Content item
+   * @param {Object} result - Publishing result
+   * @param {Object} scheduleContext - Scheduling context used
+   */
+  trackScheduledPost(item, result, scheduleContext) {
+    this.scheduledPosts.push({
+      title: item.metadata.title,
+      url: result.url,
+      scheduledFor: scheduleContext.publishDate,
+      status: scheduleContext.status,
+      platform: item.metadata.target_platform
+    });
+  }
+
+  /**
+   * Get summary of scheduled posts
+   * @returns {Object} Scheduling summary
+   */
+  getSummary() {
+    const immediate = this.scheduledPosts.filter(p => p.status === 'publish');
+    const future = this.scheduledPosts.filter(p => p.status === 'future');
+
+    return {
+      total: this.scheduledPosts.length,
+      publishedImmediately: immediate.length,
+      scheduledForFuture: future.length,
+      posts: this.scheduledPosts,
+      nextScheduled: future.length > 0
+        ? future.sort((a, b) => new Date(a.scheduledFor) - new Date(b.scheduledFor))[0]
+        : null
+    };
+  }
+
+  /**
+   * Generate scheduling report
+   * @returns {string} Markdown report of scheduled posts
+   */
+  generateScheduleReport() {
+    const summary = this.getSummary();
+
+    let report = `# Content Scheduling Report
+Generated: ${new Date().toISOString()}
+
+## Summary
+- Total Posts: ${summary.total}
+- Published Immediately: ${summary.publishedImmediately}
+- Scheduled for Future: ${summary.scheduledForFuture}
+
+`;
+
+    if (summary.scheduledForFuture > 0) {
+      report += `## Scheduled Posts
+
+| Title | Scheduled For | Platform |
+|-------|---------------|----------|
+`;
+      const futurePosts = this.scheduledPosts
+        .filter(p => p.status === 'future')
+        .sort((a, b) => new Date(a.scheduledFor) - new Date(b.scheduledFor));
+
+      for (const post of futurePosts) {
+        const date = new Date(post.scheduledFor).toLocaleString();
+        report += `| ${post.title} | ${date} | ${post.platform} |\n`;
+      }
+      report += '\n';
+    }
+
+    if (summary.publishedImmediately > 0) {
+      report += `## Published Immediately
+
+| Title | URL | Platform |
+|-------|-----|----------|
+`;
+      const immediatePosts = this.scheduledPosts.filter(p => p.status === 'publish');
+
+      for (const post of immediatePosts) {
+        report += `| ${post.title} | ${post.url} | ${post.platform} |\n`;
+      }
+    }
+
+    return report;
+  }
+}
+
+/**
+ * ContentCoordinator class
+ * Manages the state machine for content production workflow
+ */
+class ContentCoordinator {
+  /**
+   * Create a new ContentCoordinator instance
+   * @param {Object} options - Configuration options
+   */
+  constructor(options = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...options };
+    this.workDir = options.workDir;
+    this.state = this.createInitialState();
+    this.checkpointTimer = null;
+
+    // Initialize managers
+    this.contentRules = new ContentRulesManager(this.config.contentRulesPath);
+    this.analytics = new AnalyticsTracker();
+    this.webhook = new WebhookNotifier(this.config);
+    this.queue = new QueueManager(
+      path.join(this.config.outputDir, this.config.queueFileName)
+    );
+    this.publisher = new PlatformPublisher(this.config);
+    this.cronHelper = new CronHelper(this.config);
+    this.scheduler = new ScheduleManager(this.config);
+
+    this.callbacks = {
+      onProgress: null,
+      onPhaseChange: null,
+      onItemComplete: null,
+      onError: null,
+      onConfirmationNeeded: null
+    };
+  }
+
+  /**
+   * Create initial state object
+   * @returns {Object} Initial state
+   */
+  createInitialState() {
+    return {
+      phase: PHASES.INITIALIZE,
+      startedAt: null,
+      lastUpdated: null,
+      items: [],
+      results: {
+        ready: [],
+        needsReview: [],
+        failed: [],
+        published: []
+      },
+      reports: {
+        readyForPublishing: null,
+        needsReview: null,
+        analytics: null
+      },
+      stats: {
+        totalItems: 0,
+        verified: 0,
+        ready: 0,
+        needsReview: 0,
+        published: 0,
+        failed: 0
+      },
+      errors: [],
+      checkpoints: [],
+      contentRulesLoaded: false
+    };
+  }
+
+  /**
+   * Set callback functions
+   * @param {Object} callbacks - Callback functions
+   */
+  setCallbacks(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+
+  /**
+   * Load state from checkpoint file
+   * @returns {Promise<boolean>} Whether state was loaded
+   */
+  async loadCheckpoint() {
+    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    try {
+      const data = await fs.readFile(statePath, 'utf8');
+      this.state = JSON.parse(data);
+      this.log('Loaded checkpoint from', statePath);
+      return true;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        this.logError('Error loading checkpoint:', err.message);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Save state to checkpoint file
+   * @returns {Promise<void>}
+   */
+  async saveCheckpoint() {
+    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    this.state.lastUpdated = new Date().toISOString();
+    this.state.checkpoints.push({
+      phase: this.state.phase,
+      timestamp: this.state.lastUpdated,
+      stats: { ...this.state.stats }
+    });
+
+    try {
+      await fs.writeFile(statePath, JSON.stringify(this.state, null, 2));
+      this.log('Saved checkpoint to', statePath);
+    } catch (err) {
+      this.logError('Error saving checkpoint:', err.message);
+    }
+  }
+
+  /**
+   * Clear checkpoint file after successful completion
+   * @returns {Promise<void>}
+   */
+  async clearCheckpoint() {
+    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    try {
+      await fs.unlink(statePath);
+      this.log('Cleared checkpoint file');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        this.logError('Error clearing checkpoint:', err.message);
+      }
+    }
+  }
+
+  /**
+   * Load content rules
+   * @returns {Promise<void>}
+   */
+  async loadContentRules() {
+    // Try default locations if not specified
+    const possiblePaths = [
+      this.config.contentRulesPath,
+      path.join(this.workDir, 'content-rules.md'),
+      path.join(this.workDir, '..', 'content-rules.md'),
+      path.join(process.cwd(), 'content-rules.md')
+    ].filter(Boolean);
+
+    for (const rulesPath of possiblePaths) {
+      this.contentRules = new ContentRulesManager(rulesPath);
+      const rules = await this.contentRules.load();
+      if (rules) {
+        this.log('Loaded content rules from', rulesPath);
+        this.state.contentRulesLoaded = true;
+        return;
+      }
+    }
+
+    this.log('No content-rules.md found, proceeding without brand voice rules');
+  }
+
+  /**
+   * Parse content file front matter
+   * @param {string} filePath - Path to content file
+   * @returns {Promise<Object>} Parsed content item
+   */
+  async parseContentFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf8');
+    const item = {
+      id: path.basename(filePath, path.extname(filePath)),
+      filePath,
+      status: ITEM_STATUS.PENDING,
+      metadata: {},
+      content: '',
+      verification: null,
+      publishedUrl: null,
+      errors: [],
+      timing: {}
+    };
+
+    // Parse YAML front matter
+    const frontMatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+
+    if (frontMatterMatch) {
+      const frontMatter = frontMatterMatch[1];
+      item.content = frontMatterMatch[2].trim();
+
+      // Parse front matter fields
+      const lines = frontMatter.split('\n');
+      let currentKey = null;
+      let arrayMode = false;
+
+      for (const line of lines) {
+        // Check for array continuation
+        if (arrayMode && line.match(/^\s+-\s+/)) {
+          const value = line.replace(/^\s+-\s+/, '').trim().replace(/^["']|["']$/g, '');
+          if (!Array.isArray(item.metadata[currentKey])) {
+            item.metadata[currentKey] = [];
+          }
+          item.metadata[currentKey].push(value);
+          continue;
+        }
+
+        arrayMode = false;
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+          const key = line.slice(0, colonIndex).trim().toLowerCase().replace(/\s+/g, '_');
+          let value = line.slice(colonIndex + 1).trim();
+
+          // Check if this starts an array
+          if (value === '' || value === '[]') {
+            currentKey = key;
+            arrayMode = true;
+            item.metadata[key] = [];
+            continue;
+          }
+
+          // Remove quotes if present
+          if ((value.startsWith('"') && value.endsWith('"')) ||
+              (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+          }
+
+          item.metadata[key] = value;
+          currentKey = key;
+        }
+      }
+    } else {
+      // No front matter, treat entire content as body
+      item.content = content.trim();
+
+      // Try to extract title from first heading
+      const headingMatch = content.match(/^#\s+(.+)$/m);
+      if (headingMatch) {
+        item.metadata.title = headingMatch[1];
+      }
+    }
+
+    // Set defaults for required fields
+    item.metadata.title = item.metadata.title || path.basename(filePath, path.extname(filePath));
+    item.metadata.status = item.metadata.status || 'pending';
+    item.metadata.target_platform = item.metadata.target_platform || this.config.defaultPlatform;
+    item.metadata.priority = item.metadata.priority || 'normal';
+
+    return item;
+  }
+
+  /**
+   * Discover content files in work directory
+   * @returns {Promise<string[]>} Array of file paths
+   */
+  async discoverContentFiles() {
+    const files = [];
+    const entries = await fs.readdir(this.workDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isFile() && /\.(md|markdown)$/i.test(entry.name)) {
+        // Skip system files
+        if (entry.name.startsWith('.') || entry.name.startsWith('_')) continue;
+        files.push(path.join(this.workDir, entry.name));
+      }
+    }
+
+    return files.sort();
+  }
+
+  /**
+   * Phase 1: Initialize - Load and parse content files
+   * @returns {Promise<void>}
+   */
+  async phaseInitialize() {
+    this.setPhase(PHASES.INITIALIZE);
+    this.analytics.startWorkflow();
+    this.analytics.startPhase(PHASES.INITIALIZE);
+    this.state.startedAt = new Date().toISOString();
+
+    // Load content rules
+    await this.loadContentRules();
+
+    // Load queue if exists
+    await this.queue.load();
+
+    const files = await this.discoverContentFiles();
+    this.log(`Found ${files.length} content files in ${this.workDir}`);
+
+    for (const filePath of files) {
+      try {
+        const item = await this.parseContentFile(filePath);
+        this.state.items.push(item);
+      } catch (err) {
+        this.logError(`Error parsing ${filePath}:`, err.message);
+        this.state.items.push({
+          id: path.basename(filePath),
+          filePath,
+          status: ITEM_STATUS.FAILED,
+          metadata: { title: path.basename(filePath) },
+          errors: [err.message],
+          timing: {}
+        });
+      }
+    }
+
+    this.state.stats.totalItems = this.state.items.length;
+    this.analytics.setTotalItems(this.state.items.length);
+    this.analytics.endPhase(PHASES.INITIALIZE);
+
+    // Send webhook notification
+    await this.webhook.notifyStart({
+      totalItems: this.state.stats.totalItems,
+      workDir: this.workDir,
+      contentRulesLoaded: this.state.contentRulesLoaded
+    });
+
+    await this.saveCheckpoint();
+  }
+
+  /**
+   * Phase 2: Verify - Run content verification
+   * @param {Function} verifyFn - Function to verify a single item
+   * @returns {Promise<void>}
+   */
+  async phaseVerify(verifyFn) {
+    this.setPhase(PHASES.VERIFY);
+    this.analytics.startPhase(PHASES.VERIFY);
+
+    const pendingItems = this.state.items.filter(
+      item => item.status === ITEM_STATUS.PENDING
+    );
+
+    this.log(`Verifying ${pendingItems.length} items with concurrency ${this.config.concurrency}`);
+
+    // Get content rules context for verification
+    const rulesContext = this.contentRules.getVerificationContext();
+
+    // Process in batches based on concurrency
+    for (let i = 0; i < pendingItems.length; i += this.config.concurrency) {
+      const batch = pendingItems.slice(i, i + this.config.concurrency);
+
+      await Promise.all(batch.map(async (item) => {
+        item.status = ITEM_STATUS.VERIFYING;
+        const startTime = Date.now();
+
+        try {
+          // Pass content rules context to verifier
+          const result = await this.withRetry(() => verifyFn(item, rulesContext));
+          const duration = Date.now() - startTime;
+
+          item.verification = result;
+          item.status = ITEM_STATUS.VERIFIED;
+          item.timing.verification = duration;
+          this.state.stats.verified++;
+
+          this.analytics.trackVerification(item, duration);
+          this.notifyItemComplete(item, 'verified');
+        } catch (err) {
+          item.status = ITEM_STATUS.FAILED;
+          item.errors.push(err.message);
+          item.timing.verification = Date.now() - startTime;
+          this.state.stats.failed++;
+
+          this.analytics.trackError(item, err, PHASES.VERIFY);
+          this.notifyError(item, err);
+          await this.webhook.notifyError({
+            item: item.metadata.title,
+            error: err.message,
+            phase: PHASES.VERIFY
+          });
+        }
+      }));
+
+      await this.saveCheckpoint();
+    }
+
+    this.analytics.endPhase(PHASES.VERIFY);
+  }
+
+  /**
+   * Phase 3: Categorize - Sort items by verification results
+   * @returns {Promise<void>}
+   */
+  async phaseCategorize() {
+    this.setPhase(PHASES.CATEGORIZE);
+    this.analytics.startPhase(PHASES.CATEGORIZE);
+
+    for (const item of this.state.items) {
+      if (item.status === ITEM_STATUS.FAILED) {
+        this.state.results.failed.push(item);
+        continue;
+      }
+
+      if (item.status !== ITEM_STATUS.VERIFIED) {
+        continue;
+      }
+
+      const verification = item.verification || {};
+      const score = (verification.redundancyScore || '').toLowerCase();
+      const recommendation = (verification.recommendation || '').toLowerCase();
+
+      // Check if ready for publishing
+      const isLowRedundancy = [REDUNDANCY_THRESHOLDS.MINIMAL, REDUNDANCY_THRESHOLDS.LOW].includes(score);
+      const isProceedRecommended = recommendation.includes('proceed');
+
+      if (isLowRedundancy && isProceedRecommended) {
+        item.status = ITEM_STATUS.READY;
+        this.state.results.ready.push(item);
+        this.state.stats.ready++;
+      } else {
+        item.status = ITEM_STATUS.NEEDS_REVIEW;
+        this.state.results.needsReview.push(item);
+        this.state.stats.needsReview++;
+      }
+    }
+
+    this.analytics.endPhase(PHASES.CATEGORIZE);
+    await this.saveCheckpoint();
+  }
+
+  /**
+   * Phase 4: Report - Generate output reports
+   * @returns {Promise<void>}
+   */
+  async phaseReport() {
+    this.setPhase(PHASES.REPORT);
+    this.analytics.startPhase(PHASES.REPORT);
+
+    const timestamp = this.getTimestamp();
+
+    // Generate Ready for Publishing report
+    if (this.state.results.ready.length > 0) {
+      const readyReport = this.generateReadyReport(timestamp);
+      const readyPath = path.join(
+        this.config.outputDir,
+        `ready-for-publishing-${timestamp}.md`
+      );
+      await fs.writeFile(readyPath, readyReport);
+      this.state.reports.readyForPublishing = readyPath;
+      this.log('Generated report:', readyPath);
+    }
+
+    // Generate Needs Review report
+    if (this.state.results.needsReview.length > 0 || this.state.results.failed.length > 0) {
+      const reviewReport = this.generateNeedsReviewReport(timestamp);
+      const reviewPath = path.join(
+        this.config.outputDir,
+        `needs-review-${timestamp}.md`
+      );
+      await fs.writeFile(reviewPath, reviewReport);
+      this.state.reports.needsReview = reviewPath;
+      this.log('Generated report:', reviewPath);
+    }
+
+    // Generate analytics report if enabled
+    if (this.config.enableAnalytics) {
+      const analyticsReport = this.generateAnalyticsReport(timestamp);
+      const analyticsPath = path.join(
+        this.config.outputDir,
+        `analytics-${timestamp}.md`
+      );
+      await fs.writeFile(analyticsPath, analyticsReport);
+      this.state.reports.analytics = analyticsPath;
+      this.log('Generated analytics report:', analyticsPath);
+    }
+
+    this.analytics.endPhase(PHASES.REPORT);
+    await this.saveCheckpoint();
+  }
+
+  /**
+   * Phase 5: Notify - Inform user of results
+   * @returns {Promise<Object>} Summary for user notification
+   */
+  async phaseNotify() {
+    this.setPhase(PHASES.NOTIFY);
+
+    return {
+      summary: {
+        total: this.state.stats.totalItems,
+        ready: this.state.stats.ready,
+        needsReview: this.state.stats.needsReview,
+        failed: this.state.stats.failed
+      },
+      reports: this.state.reports,
+      readyItems: this.state.results.ready.map(item => ({
+        title: item.metadata.title,
+        score: item.verification?.redundancyScore,
+        recommendation: item.verification?.recommendation,
+        platform: item.metadata.target_platform
+      })),
+      needsReviewItems: this.state.results.needsReview.map(item => ({
+        title: item.metadata.title,
+        score: item.verification?.redundancyScore,
+        reason: item.verification?.feedback || 'Requires manual review'
+      })),
+      contentRulesApplied: this.state.contentRulesLoaded
+    };
+  }
+
+  /**
+   * Phase 6: Publish - Publish approved content
+   * @param {Function} publishFn - Function to publish a single item
+   * @returns {Promise<void>}
+   */
+  async phasePublish(publishFn) {
+    if (this.config.dryRun) {
+      this.log('Dry run mode - skipping publish phase');
+      this.setPhase(PHASES.COMPLETE);
+      return;
+    }
+
+    this.setPhase(PHASES.PUBLISH);
+    this.analytics.startPhase(PHASES.PUBLISH);
+
+    const readyItems = this.state.results.ready.filter(
+      item => item.status === ITEM_STATUS.READY
+    );
+
+    // Get publishing context from content rules
+    const publishContext = this.contentRules.getPublishingContext();
+
+    this.log(`Publishing ${readyItems.length} items with concurrency ${this.config.concurrency}`);
+
+    // Process in batches based on concurrency
+    for (let i = 0; i < readyItems.length; i += this.config.concurrency) {
+      const batch = readyItems.slice(i, i + this.config.concurrency);
+      const batchStartIndex = i;
+
+      await Promise.all(batch.map(async (item, batchIndex) => {
+        item.status = ITEM_STATUS.PUBLISHING;
+        const startTime = Date.now();
+        const itemIndex = batchStartIndex + batchIndex;
+
+        try {
+          // Get platform-specific publisher
+          const platform = item.metadata.target_platform || this.config.defaultPlatform;
+          const platformPublisher = this.publisher.getPublisher(platform);
+
+          // Get scheduling context for WordPress native scheduling
+          const scheduleContext = this.scheduler.getSchedulingContext(
+            item,
+            itemIndex,
+            readyItems.length
+          );
+
+          // Publish with platform context, content rules, and scheduling
+          const result = await this.withRetry(() =>
+            platformPublisher.publish(item, (item, platformContext) =>
+              publishFn(item, {
+                ...platformContext,
+                contentRules: publishContext,
+                scheduling: scheduleContext
+              })
+            )
+          );
+
+          const duration = Date.now() - startTime;
+
+          item.publishedUrl = result.url;
+          item.publishedAt = new Date().toISOString();
+          item.scheduledFor = scheduleContext.isScheduled ? scheduleContext.publishDate : null;
+          item.status = scheduleContext.isScheduled ? ITEM_STATUS.PUBLISHED : ITEM_STATUS.PUBLISHED;
+          item.timing.publishing = duration;
+          this.state.results.published.push(item);
+          this.state.stats.published++;
+
+          // Track in scheduler
+          this.scheduler.trackScheduledPost(item, result, scheduleContext);
+
+          this.analytics.trackPublishing(item, duration);
+          this.notifyItemComplete(item, scheduleContext.isScheduled ? 'scheduled' : 'published');
+
+          // Update queue status
+          await this.queue.updateItemStatus(item.id, 'published', {
+            publishedUrl: result.url,
+            publishedAt: item.publishedAt,
+            scheduledFor: item.scheduledFor
+          });
+
+          // Webhook notification
+          await this.webhook.notifyPublished({
+            title: item.metadata.title,
+            url: result.url,
+            platform,
+            scheduled: scheduleContext.isScheduled,
+            scheduledFor: scheduleContext.scheduledFor
+          });
+
+        } catch (err) {
+          item.status = ITEM_STATUS.FAILED;
+          item.errors.push(err.message);
+          item.timing.publishing = Date.now() - startTime;
+          this.state.stats.failed++;
+
+          this.analytics.trackError(item, err, PHASES.PUBLISH);
+          this.notifyError(item, err);
+
+          await this.queue.updateItemStatus(item.id, 'failed', {
+            error: err.message
+          });
+
+          await this.webhook.notifyError({
+            item: item.metadata.title,
+            error: err.message,
+            phase: PHASES.PUBLISH
+          });
+        }
+      }));
+
+      await this.saveCheckpoint();
+    }
+
+    this.analytics.endPhase(PHASES.PUBLISH);
+    this.setPhase(PHASES.COMPLETE);
+  }
+
+  /**
+   * Run the complete workflow
+   * @param {Object} handlers - Phase handlers
+   * @returns {Promise<Object>} Final results
+   */
+  async run(handlers) {
+    const { verify, publish, confirm } = handlers;
+
+    // Cron mode: acquire lock and check run interval
+    if (this.config.cronMode) {
+      const lockAcquired = await this.cronHelper.acquireLock();
+      if (!lockAcquired) {
+        if (!this.config.quietMode) {
+          console.log('[ContentCoordinator] Another instance is running, exiting');
+        }
+        return { skipped: true, reason: 'lock_held' };
+      }
+
+      const intervalCheck = await this.cronHelper.checkRunInterval();
+      if (!intervalCheck.canRun) {
+        await this.cronHelper.releaseLock();
+        if (!this.config.quietMode) {
+          console.log(`[ContentCoordinator] Minimum interval not met, next run at ${intervalCheck.nextRunTime}`);
+        }
+        return { skipped: true, reason: 'interval_not_met', nextRunTime: intervalCheck.nextRunTime };
+      }
+    }
+
+    try {
+      // Try to resume from checkpoint
+      const resumed = await this.loadCheckpoint();
+      if (resumed && this.state.phase !== PHASES.INITIALIZE) {
+        this.log(`Resuming from phase: ${this.state.phase}`);
+      }
+
+      // Run phases based on current state
+      if (this.state.phase === PHASES.INITIALIZE) {
+        await this.phaseInitialize();
+      }
+
+      if (this.state.phase === PHASES.INITIALIZE || this.state.phase === PHASES.VERIFY) {
+        await this.phaseVerify(verify);
+      }
+
+      if ([PHASES.INITIALIZE, PHASES.VERIFY, PHASES.CATEGORIZE].includes(this.state.phase)) {
+        await this.phaseCategorize();
+      }
+
+      if ([PHASES.INITIALIZE, PHASES.VERIFY, PHASES.CATEGORIZE, PHASES.REPORT].includes(this.state.phase)) {
+        await this.phaseReport();
+      }
+
+      const notification = await this.phaseNotify();
+
+      // Request confirmation if not in force mode (skip in cron mode)
+      if (!this.config.force && !this.config.cronMode && this.state.results.ready.length > 0) {
+        if (confirm) {
+          const confirmed = await confirm(notification);
+          if (!confirmed) {
+            this.log('Publishing cancelled by user');
+            this.analytics.endWorkflow();
+            if (this.config.cronMode) {
+              await this.cronHelper.releaseLock();
+            }
+            return this.getFinalResults();
+          }
+        }
+      }
+
+      if (this.state.results.ready.length > 0) {
+        await this.phasePublish(publish);
+      }
+
+      // End workflow tracking
+      this.analytics.endWorkflow();
+
+      // Clear checkpoint on successful completion
+      await this.clearCheckpoint();
+
+      // Final webhook notification
+      const results = this.getFinalResults();
+
+      // Add scheduling summary to results
+      results.scheduling = this.scheduler.getSummary();
+
+      await this.webhook.notifyComplete(results);
+
+      // Cron mode: record run and release lock
+      if (this.config.cronMode) {
+        await this.cronHelper.recordRun(results);
+        await this.cronHelper.releaseLock();
+      }
+
+      return results;
+
+    } catch (err) {
+      this.logError('Workflow error:', err.message);
+      this.analytics.endWorkflow();
+      await this.saveCheckpoint();
+      await this.webhook.notifyError({
+        error: err.message,
+        phase: this.state.phase
+      });
+
+      // Cron mode: release lock on error
+      if (this.config.cronMode) {
+        await this.cronHelper.releaseLock();
+      }
+
+      throw err;
+    }
+  }
+
+  /**
+   * Get final results summary
+   * @returns {Object} Final results
+   */
+  getFinalResults() {
+    return {
+      success: this.state.stats.failed === 0,
+      stats: this.state.stats,
+      reports: this.state.reports,
+      published: this.state.results.published.map(item => ({
+        title: item.metadata.title,
+        url: item.publishedUrl,
+        platform: item.metadata.target_platform
+      })),
+      needsReview: this.state.results.needsReview.map(item => ({
+        title: item.metadata.title,
+        reason: item.verification?.feedback || 'Requires review'
+      })),
+      failed: this.state.results.failed.map(item => ({
+        title: item.metadata.title,
+        errors: item.errors
+      })),
+      duration: this.calculateDuration(),
+      analytics: this.config.enableAnalytics ? this.analytics.getSummary() : null,
+      contentRulesApplied: this.state.contentRulesLoaded
+    };
+  }
+
+  /**
+   * Generate ready for publishing report
+   * @param {string} timestamp - Report timestamp
+   * @returns {string} Markdown report
+   */
+  generateReadyReport(timestamp) {
+    const items = this.state.results.ready;
+    const totalWords = items.reduce((sum, item) => {
+      return sum + (item.content?.split(/\s+/).length || 0);
+    }, 0);
+
+    let report = `# Content Ready for Publishing
+Generated: ${this.formatTimestamp(timestamp)}
+
+## Summary
+- Total Items: ${items.length}
+- Total Word Count: ~${Math.round(totalWords / 1000)}K words
+- Average Redundancy Score: ${this.calculateAverageScore(items)}
+- Content Rules Applied: ${this.state.contentRulesLoaded ? 'Yes' : 'No'}
+
+## Items
+
+`;
+
+    items.forEach((item, index) => {
+      const v = item.verification || {};
+      report += `### ${index + 1}. ${item.metadata.title}
+- **File**: ${path.basename(item.filePath)}
+- **Redundancy Score**: ${v.redundancyScore || 'N/A'}
+- **Recommendation**: ${v.recommendation || 'N/A'}
+- **Word Count**: ~${item.content?.split(/\s+/).length || 0} words
+- **Verifier Feedback**: ${v.feedback || 'No feedback provided'}
+- **Target Platform**: ${item.metadata.target_platform || 'wordpress'}
+- **Priority**: ${item.metadata.priority || 'normal'}
+
+`;
+    });
+
+    return report;
+  }
+
+  /**
+   * Generate needs review report
+   * @param {string} timestamp - Report timestamp
+   * @returns {string} Markdown report
+   */
+  generateNeedsReviewReport(timestamp) {
+    const reviewItems = this.state.results.needsReview;
+    const failedItems = this.state.results.failed;
+
+    let report = `# Content Requiring Review
+Generated: ${this.formatTimestamp(timestamp)}
+
+## Summary
+- Items Needing Review: ${reviewItems.length}
+- Failed Items: ${failedItems.length}
+- Total: ${reviewItems.length + failedItems.length}
+
+`;
+
+    if (reviewItems.length > 0) {
+      report += `## Items Needing Review
+
+`;
+      reviewItems.forEach((item, index) => {
+        const v = item.verification || {};
+        report += `### ${index + 1}. ${item.metadata.title}
+- **File**: ${path.basename(item.filePath)}
+- **Redundancy Score**: ${v.redundancyScore || 'N/A'}
+- **Recommendation**: ${v.recommendation || 'N/A'}
+- **Issue**: ${this.getReviewReason(item)}
+- **Verifier Feedback**: ${v.feedback || 'No feedback provided'}
+- **Suggested Actions**:
+  - Review and revise proprietary content
+  - Ensure content adds unique value
+  - Re-submit for verification after changes
+
+`;
+      });
+    }
+
+    if (failedItems.length > 0) {
+      report += `## Failed Items
+
+`;
+      failedItems.forEach((item, index) => {
+        report += `### ${index + 1}. ${item.metadata.title}
+- **File**: ${path.basename(item.filePath)}
+- **Errors**:
+${item.errors.map(e => `  - ${e}`).join('\n')}
+- **Suggested Actions**:
+  - Review file format and content
+  - Fix any parsing errors
+  - Re-submit for processing
+
+`;
+      });
+    }
+
+    return report;
+  }
+
+  /**
+   * Generate analytics report
+   * @param {string} timestamp - Report timestamp
+   * @returns {string} Markdown report
+   */
+  generateAnalyticsReport(timestamp) {
+    const analytics = this.analytics.getSummary();
+
+    let report = `# Content Coordination Analytics
+Generated: ${this.formatTimestamp(timestamp)}
+
+## Workflow Summary
+- **Total Duration**: ${analytics.summary.totalDuration}
+- **Success Rate**: ${analytics.summary.successRate}
+- **Average Quality Score**: ${analytics.summary.avgQualityScore}
+
+## Item Statistics
+| Metric | Count |
+|--------|-------|
+| Total Items | ${analytics.items.total} |
+| Verified | ${analytics.items.verified} |
+| Published | ${analytics.items.published} |
+| Failed | ${analytics.items.failed} |
+
+## Performance Metrics
+| Metric | Value |
+|--------|-------|
+| Avg Verification Time | ${analytics.summary.avgVerificationTime} |
+| Avg Publish Time | ${analytics.summary.avgPublishTime} |
+| Total Verification Time | ${this.analytics.formatDuration(analytics.performance.totalVerificationTime)} |
+| Total Publish Time | ${this.analytics.formatDuration(analytics.performance.totalPublishTime)} |
+
+## Phase Timing
+`;
+
+    for (const [phase, data] of Object.entries(analytics.workflow.phases)) {
+      report += `- **${phase}**: ${this.analytics.formatDuration(data.duration)}\n`;
+    }
+
+    report += `
+## Quality Metrics
+- **Average Redundancy Score**: ${analytics.quality.avgRedundancyScore.toFixed(2)}/4 (lower is better)
+- **Average Uniqueness Score**: ${(analytics.quality.avgUniquenessScore * 100).toFixed(1)}%
+
+`;
+
+    if (analytics.errors.length > 0) {
+      report += `## Errors (${analytics.errors.length})
+`;
+      analytics.errors.forEach((err, i) => {
+        report += `${i + 1}. **${err.item}** (${err.phase}): ${err.error}\n`;
+      });
+    }
+
+    return report;
+  }
+
+  /**
+   * Get reason why item needs review
+   * @param {Object} item - Content item
+   * @returns {string} Review reason
+   */
+  getReviewReason(item) {
+    const v = item.verification || {};
+    const score = (v.redundancyScore || '').toLowerCase();
+    const rec = (v.recommendation || '').toLowerCase();
+
+    if (score === 'high') return 'High redundancy - content may duplicate existing knowledge';
+    if (score === 'medium') return 'Medium redundancy - consider adding more unique insights';
+    if (rec.includes('reject')) return 'Content rejected by verifier';
+    if (rec.includes('review')) return 'Manual review recommended';
+
+    return 'Content requires attention before publishing';
+  }
+
+  /**
+   * Calculate average redundancy score
+   * @param {Object[]} items - Items to calculate from
+   * @returns {string} Average score label
+   */
+  calculateAverageScore(items) {
+    const scores = { minimal: 1, low: 2, medium: 3, high: 4 };
+    let total = 0;
+    let count = 0;
+
+    for (const item of items) {
+      const score = (item.verification?.redundancyScore || '').toLowerCase();
+      if (scores[score]) {
+        total += scores[score];
+        count++;
+      }
+    }
+
+    if (count === 0) return 'N/A';
+
+    const avg = total / count;
+    if (avg <= 1.5) return 'Minimal';
+    if (avg <= 2.5) return 'Low';
+    if (avg <= 3.5) return 'Medium';
+    return 'High';
+  }
+
+  /**
+   * Execute function with retry logic
+   * @param {Function} fn - Function to execute
+   * @returns {Promise<*>} Function result
+   */
+  async withRetry(fn) {
+    let lastError;
+
+    for (let attempt = 1; attempt <= this.config.retryAttempts; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.config.retryAttempts) {
+          this.log(`Retry attempt ${attempt}/${this.config.retryAttempts} after error:`, err.message);
+          await this.sleep(this.config.retryDelay * attempt);
+        }
+      }
+    }
+
+    throw lastError;
+  }
+
+  /**
+   * Set current phase and notify
+   * @param {string} phase - New phase
+   */
+  setPhase(phase) {
+    const previousPhase = this.state.phase;
+    this.state.phase = phase;
+
+    if (this.callbacks.onPhaseChange) {
+      this.callbacks.onPhaseChange(phase, previousPhase);
+    }
+
+    this.log(`Phase: ${previousPhase} -> ${phase}`);
+  }
+
+  /**
+   * Notify item completion
+   * @param {Object} item - Completed item
+   * @param {string} action - Action completed
+   */
+  notifyItemComplete(item, action) {
+    if (this.callbacks.onItemComplete) {
+      this.callbacks.onItemComplete(item, action);
+    }
+
+    if (this.callbacks.onProgress) {
+      this.callbacks.onProgress(this.state.stats);
+    }
+  }
+
+  /**
+   * Notify error
+   * @param {Object} item - Item with error
+   * @param {Error} error - Error object
+   */
+  notifyError(item, error) {
+    this.state.errors.push({
+      item: item.metadata.title,
+      error: error.message,
+      timestamp: new Date().toISOString()
+    });
+
+    if (this.callbacks.onError) {
+      this.callbacks.onError(item, error);
+    }
+  }
+
+  /**
+   * Get timestamp string
+   * @returns {string} Formatted timestamp
+   */
+  getTimestamp() {
+    const now = new Date();
+    return now.toISOString()
+      .replace(/T/, '-')
+      .replace(/:/g, '-')
+      .replace(/\..+/, '');
+  }
+
+  /**
+   * Format timestamp for display
+   * @param {string} timestamp - Timestamp to format
+   * @returns {string} Human-readable timestamp
+   */
+  formatTimestamp(timestamp) {
+    return timestamp.replace(/-/g, (m, i) => i > 9 ? ':' : '-').replace('-', ' ');
+  }
+
+  /**
+   * Calculate workflow duration
+   * @returns {string} Duration string
+   */
+  calculateDuration() {
+    if (!this.state.startedAt) return 'N/A';
+
+    const start = new Date(this.state.startedAt);
+    const end = new Date();
+    const ms = end - start;
+
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+  }
+
+  /**
+   * Sleep for specified duration
+   * @param {number} ms - Milliseconds to sleep
+   * @returns {Promise<void>}
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Log message if verbose mode
+   * @param {...*} args - Log arguments
+   */
+  log(...args) {
+    if (this.config.verbose) {
+      console.log('[ContentCoordinator]', ...args);
+    }
+  }
+
+  /**
+   * Log error
+   * @param {...*} args - Error arguments
+   */
+  logError(...args) {
+    console.error('[ContentCoordinator Error]', ...args);
+  }
+
+  // ============================================
+  // Queue Management Methods
+  // ============================================
+
+  /**
+   * Add item to persistent queue
+   * @param {Object} item - Item to add
+   * @returns {Promise<Object>} Added item
+   */
+  async addToQueue(item) {
+    return this.queue.addItem(item);
+  }
+
+  /**
+   * Remove item from queue
+   * @param {string} id - Item ID
+   * @returns {Promise<boolean>} Success
+   */
+  async removeFromQueue(id) {
+    return this.queue.removeItem(id);
+  }
+
+  /**
+   * Get queue statistics
+   * @returns {Object} Queue stats
+   */
+  getQueueStats() {
+    return this.queue.getStats();
+  }
+
+  /**
+   * Clear completed items from queue
+   * @returns {Promise<number>} Number cleared
+   */
+  async clearCompletedFromQueue() {
+    return this.queue.clearCompleted();
+  }
+
+  /**
+   * Get available publishing platforms
+   * @returns {string[]} Platform names
+   */
+  getAvailablePlatforms() {
+    return this.publisher.getAvailablePlatforms();
+  }
+
+  // ============================================
+  // Cron & Scheduling Methods
+  // ============================================
+
+  /**
+   * Generate crontab entry for automated scheduling
+   * @param {Object} options - Crontab options
+   * @returns {string} Crontab entry
+   */
+  generateCrontabEntry(options = {}) {
+    return this.cronHelper.generateCrontabEntry({
+      workDir: this.workDir || process.cwd(),
+      ...options
+    });
+  }
+
+  /**
+   * Get suggested cron schedules
+   * @returns {Object[]} Array of schedule suggestions
+   */
+  getSuggestedSchedules() {
+    return this.cronHelper.getSuggestedSchedules();
+  }
+
+  /**
+   * Validate a cron expression
+   * @param {string} expression - Cron expression to validate
+   * @returns {{valid: boolean, error?: string}}
+   */
+  validateCronExpression(expression) {
+    return this.cronHelper.validateCronExpression(expression);
+  }
+
+  /**
+   * Get last run information
+   * @returns {Promise<Object|null>}
+   */
+  async getLastRun() {
+    return this.cronHelper.getLastRun();
+  }
+
+  /**
+   * Get scheduling summary
+   * @returns {Object} Scheduling summary
+   */
+  getSchedulingSummary() {
+    return this.scheduler.getSummary();
+  }
+
+  /**
+   * Generate scheduling report
+   * @returns {string} Markdown scheduling report
+   */
+  generateScheduleReport() {
+    return this.scheduler.generateScheduleReport();
+  }
+
+  /**
+   * Check if lock is currently held
+   * @returns {Promise<boolean>}
+   */
+  async isLocked() {
+    try {
+      await fs.access(this.cronHelper.lockPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Force release lock (use with caution)
+   * @returns {Promise<void>}
+   */
+  async forceReleaseLock() {
+    await this.cronHelper.releaseLock();
+  }
+
+  /**
+   * Setup crontab entry (prints instructions)
+   * @param {Object} options - Setup options
+   * @returns {string} Setup instructions
+   */
+  getCrontabSetupInstructions(options = {}) {
+    const entry = this.generateCrontabEntry(options);
+    const schedules = this.getSuggestedSchedules();
+
+    return `
+# Content Coordinator Crontab Setup
+# ==================================
+
+## Quick Setup
+
+1. Open crontab for editing:
+   crontab -e
+
+2. Add one of the following entries:
+
+${entry}
+
+## Suggested Schedules
+
+${schedules.map(s => `### ${s.name}
+# ${s.description}
+# Schedule: ${s.schedule}
+`).join('\n')}
+
+## Environment Variables
+
+Make sure these are set in your crontab or script:
+- WORDPRESS_URL
+- WORDPRESS_USERNAME
+- WORDPRESS_APP_PASSWORD
+
+## Log Rotation (optional)
+
+Add to /etc/logrotate.d/content-coordinator:
+\`\`\`
+/var/log/content-coordinator.log {
+    weekly
+    rotate 4
+    compress
+    missingok
+    notifempty
+}
+\`\`\`
+
+## Verify Setup
+
+After adding, verify with:
+   crontab -l
+
+Check logs at:
+   tail -f /var/log/content-coordinator.log
+`;
+  }
+}
+
+// Export for use in other modules
+export {
+  ContentCoordinator,
+  ContentRulesManager,
+  AnalyticsTracker,
+  WebhookNotifier,
+  QueueManager,
+  PlatformPublisher,
+  CronHelper,
+  ScheduleManager,
+  PHASES,
+  ITEM_STATUS,
+  REDUNDANCY_THRESHOLDS,
+  PLATFORMS,
+  DEFAULT_CONFIG
+};
+
+// Default export for convenience
+export default ContentCoordinator;