myaidev-method 0.3.4 → 0.3.6

package/src/lib/{content-coordinator.js → content-production-coordinator.js}

@@ -5,64 +5,64 @@
  * Provides checkpoint/resume capability, error isolation, progress tracking,
  * multi-platform publishing, analytics, webhooks, and queue management.
  *
- * @module content-coordinator
+ * @module content-production-coordinator
  */
 
-import fs from 'fs/promises';
-import path from 'path';
-import https from 'https';
-import http from 'http';
-import os from 'os';
+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'
+  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',
-  SCHEDULED: 'scheduled',
-  FAILED: 'failed',
-  SKIPPED: 'skipped'
+  PENDING: "pending",
+  VERIFYING: "verifying",
+  VERIFIED: "verified",
+  READY: "ready",
+  NEEDS_REVIEW: "needs_review",
+  PUBLISHING: "publishing",
+  PUBLISHED: "published",
+  SCHEDULED: "scheduled",
+  FAILED: "failed",
+  SKIPPED: "skipped",
 };
 
 /**
  * Redundancy score thresholds
  */
 const REDUNDANCY_THRESHOLDS = {
-  MINIMAL: 'minimal',
-  LOW: 'low',
-  MEDIUM: 'medium',
-  HIGH: 'high'
+  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'
+  WORDPRESS: "wordpress",
+  PAYLOADCMS: "payloadcms",
+  STATIC: "static",
+  DOCUSAURUS: "docusaurus",
+  MINTLIFY: "mintlify",
+  ASTRO: "astro",
 };
 
 /**
@@ -73,9 +73,9 @@ const DEFAULT_CONFIG = {
   retryAttempts: 2,
   retryDelay: 1000,
   checkpointInterval: 5000,
-  stateFileName: '.content-coordinator-state.json',
-  queueFileName: '.content-queue.json',
-  outputDir: '.',
+  stateFileName: ".content-production-coordinator-state.json",
+  queueFileName: ".content-queue.json",
+  outputDir: ".",
   dryRun: false,
   force: false,
   verbose: false,
@@ -83,21 +83,21 @@ const DEFAULT_CONFIG = {
   contentRulesPath: null,
   // Webhooks
   webhookUrl: null,
-  webhookEvents: ['complete', 'error'],
+  webhookEvents: ["complete", "error"],
   // Analytics
   enableAnalytics: true,
   // Platform
   defaultPlatform: PLATFORMS.WORDPRESS,
   // Cron/Scheduling
   cronMode: false,
-  lockFileName: '.content-coordinator.lock',
-  lastRunFileName: '.content-coordinator-lastrun.json',
+  lockFileName: ".content-production-coordinator.lock",
+  lastRunFileName: ".content-production-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)
+  publishSpreadInterval: 0, // Hours between scheduled posts (0 = no spreading)
 };
 
 /**
@@ -118,13 +118,13 @@ class ContentRulesManager {
     if (!this.rulesPath) return null;
 
     try {
-      const content = await fs.readFile(this.rulesPath, 'utf8');
+      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);
+      if (err.code !== "ENOENT") {
+        console.error("[ContentRules] Error loading rules:", err.message);
       }
       return null;
     }
@@ -142,28 +142,28 @@ class ContentRulesManager {
       writingStyle: {},
       seoGuidelines: {},
       formatting: {},
-      contentBoundaries: {}
+      contentBoundaries: {},
     };
 
     // Extract sections using markdown headers
     const sections = content.split(/^## /m).slice(1);
 
     for (const section of sections) {
-      const lines = section.split('\n');
+      const lines = section.split("\n");
       const header = lines[0].trim().toLowerCase();
-      const body = lines.slice(1).join('\n').trim();
+      const body = lines.slice(1).join("\n").trim();
 
-      if (header.includes('brand') || header.includes('identity')) {
+      if (header.includes("brand") || header.includes("identity")) {
         rules.brandIdentity = this.parseSection(body);
-      } else if (header.includes('voice') || header.includes('tone')) {
+      } else if (header.includes("voice") || header.includes("tone")) {
         rules.voiceTone = this.parseSection(body);
-      } else if (header.includes('writing') || header.includes('style')) {
+      } else if (header.includes("writing") || header.includes("style")) {
         rules.writingStyle = this.parseSection(body);
-      } else if (header.includes('seo')) {
+      } else if (header.includes("seo")) {
         rules.seoGuidelines = this.parseSection(body);
-      } else if (header.includes('format')) {
+      } else if (header.includes("format")) {
         rules.formatting = this.parseSection(body);
-      } else if (header.includes('boundar') || header.includes('avoid')) {
+      } else if (header.includes("boundar") || header.includes("avoid")) {
         rules.contentBoundaries = this.parseSection(body);
       }
     }
@@ -178,13 +178,13 @@ class ContentRulesManager {
    */
   parseSection(body) {
     const result = {};
-    const lines = body.split('\n');
+    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, '_');
+        const key = match[1].trim().toLowerCase().replace(/\s+/g, "_");
         result[key] = match[2].trim();
       }
       // Parse simple list items: - Value
@@ -209,7 +209,7 @@ class ContentRulesManager {
       brandVoice: this.rules.voiceTone,
       writingStyle: this.rules.writingStyle,
       contentBoundaries: this.rules.contentBoundaries,
-      checkBrandAlignment: true
+      checkBrandAlignment: true,
     };
   }
 
@@ -223,7 +223,7 @@ class ContentRulesManager {
     return {
       brandIdentity: this.rules.brandIdentity,
       seoGuidelines: this.rules.seoGuidelines,
-      formatting: this.rules.formatting
+      formatting: this.rules.formatting,
     };
   }
 }
@@ -238,27 +238,27 @@ class AnalyticsTracker {
         startTime: null,
         endTime: null,
         duration: null,
-        phases: {}
+        phases: {},
       },
       items: {
         total: 0,
         verified: 0,
         published: 0,
         failed: 0,
-        skipped: 0
+        skipped: 0,
       },
       performance: {
         avgVerificationTime: 0,
         avgPublishTime: 0,
         totalVerificationTime: 0,
-        totalPublishTime: 0
+        totalPublishTime: 0,
       },
       quality: {
         avgRedundancyScore: 0,
         avgUniquenessScore: 0,
-        contentQualityTrend: []
+        contentQualityTrend: [],
       },
-      errors: []
+      errors: [],
     };
     this.phaseTimers = {};
   }
@@ -275,7 +275,8 @@ class AnalyticsTracker {
    */
   endWorkflow() {
     this.metrics.workflow.endTime = Date.now();
-    this.metrics.workflow.duration = this.metrics.workflow.endTime - this.metrics.workflow.startTime;
+    this.metrics.workflow.duration =
+      this.metrics.workflow.endTime - this.metrics.workflow.startTime;
   }
 
   /**
@@ -294,7 +295,7 @@ class AnalyticsTracker {
     if (this.phaseTimers[phase]) {
       this.metrics.workflow.phases[phase] = {
         duration: Date.now() - this.phaseTimers[phase],
-        completedAt: new Date().toISOString()
+        completedAt: new Date().toISOString(),
       };
     }
   }
@@ -308,18 +309,19 @@ class AnalyticsTracker {
     this.metrics.items.verified++;
     this.metrics.performance.totalVerificationTime += duration;
     this.metrics.performance.avgVerificationTime =
-      this.metrics.performance.totalVerificationTime / this.metrics.items.verified;
+      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();
+      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()
+          timestamp: new Date().toISOString(),
         });
 
         // Update averages
@@ -327,7 +329,8 @@ class AnalyticsTracker {
         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;
+          trend.reduce((sum, t) => sum + (t.uniquenessScore || 0), 0) /
+          trend.length;
       }
     }
   }
@@ -353,10 +356,10 @@ class AnalyticsTracker {
   trackError(item, error, phase) {
     this.metrics.items.failed++;
     this.metrics.errors.push({
-      item: item.metadata?.title || 'Unknown',
+      item: item.metadata?.title || "Unknown",
       error: error.message,
       phase,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
   }
 
@@ -373,19 +376,28 @@ class AnalyticsTracker {
    * @returns {Object} Analytics summary
    */
   getSummary() {
-    const successRate = this.metrics.items.total > 0
-      ? ((this.metrics.items.published / this.metrics.items.total) * 100).toFixed(1)
-      : 0;
+    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'
-      }
+        avgVerificationTime: this.formatDuration(
+          this.metrics.performance.avgVerificationTime,
+        ),
+        avgPublishTime: this.formatDuration(
+          this.metrics.performance.avgPublishTime,
+        ),
+        avgQualityScore:
+          (5 - this.metrics.quality.avgRedundancyScore).toFixed(2) + "/4",
+      },
     };
   }
 
@@ -395,7 +407,7 @@ class AnalyticsTracker {
    * @returns {string} Formatted duration
    */
   formatDuration(ms) {
-    if (!ms) return 'N/A';
+    if (!ms) return "N/A";
     const seconds = Math.floor(ms / 1000);
     const minutes = Math.floor(seconds / 60);
     const hours = Math.floor(minutes / 60);
@@ -412,7 +424,7 @@ class AnalyticsTracker {
 class WebhookNotifier {
   constructor(config) {
     this.url = config.webhookUrl;
-    this.events = config.webhookEvents || ['complete', 'error'];
+    this.events = config.webhookEvents || ["complete", "error"];
     this.enabled = !!this.url;
   }
 
@@ -430,7 +442,7 @@ class WebhookNotifier {
     const data = JSON.stringify({
       event,
       timestamp: new Date().toISOString(),
-      payload
+      payload,
     });
 
     return new Promise((resolve) => {
@@ -438,23 +450,23 @@ class WebhookNotifier {
         const urlObj = new URL(this.url);
         const options = {
           hostname: urlObj.hostname,
-          port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+          port: urlObj.port || (urlObj.protocol === "https:" ? 443 : 80),
           path: urlObj.pathname + urlObj.search,
-          method: 'POST',
+          method: "POST",
           headers: {
-            'Content-Type': 'application/json',
-            'Content-Length': Buffer.byteLength(data),
-            'User-Agent': 'ContentCoordinator/1.0'
-          }
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(data),
+            "User-Agent": "ContentCoordinator/1.0",
+          },
         };
 
-        const protocol = urlObj.protocol === 'https:' ? https : http;
+        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);
+        req.on("error", (err) => {
+          console.error("[Webhook] Error:", err.message);
           resolve(false);
         });
 
@@ -466,7 +478,7 @@ class WebhookNotifier {
         req.write(data);
         req.end();
       } catch (err) {
-        console.error('[Webhook] Error:', err.message);
+        console.error("[Webhook] Error:", err.message);
         resolve(false);
       }
     });
@@ -477,7 +489,7 @@ class WebhookNotifier {
    * @param {Object} info - Workflow info
    */
   async notifyStart(info) {
-    await this.notify('start', info);
+    await this.notify("start", info);
   }
 
   /**
@@ -485,7 +497,7 @@ class WebhookNotifier {
    * @param {Object} results - Final results
    */
   async notifyComplete(results) {
-    await this.notify('complete', results);
+    await this.notify("complete", results);
   }
 
   /**
@@ -493,7 +505,7 @@ class WebhookNotifier {
    * @param {Object} error - Error info
    */
   async notifyError(error) {
-    await this.notify('error', error);
+    await this.notify("error", error);
   }
 
   /**
@@ -501,7 +513,7 @@ class WebhookNotifier {
    * @param {Object} item - Published item info
    */
   async notifyPublished(item) {
-    await this.notify('published', item);
+    await this.notify("published", item);
   }
 }
 
@@ -512,10 +524,10 @@ class QueueManager {
   constructor(queuePath) {
     this.queuePath = queuePath;
     this.queue = {
-      version: '1.0',
+      version: "1.0",
       created: null,
       updated: null,
-      items: []
+      items: [],
     };
   }
 
@@ -525,12 +537,12 @@ class QueueManager {
    */
   async load() {
     try {
-      const data = await fs.readFile(this.queuePath, 'utf8');
+      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);
+      if (err.code !== "ENOENT") {
+        console.error("[QueueManager] Error loading queue:", err.message);
       }
       this.queue.created = new Date().toISOString();
       return this.queue;
@@ -555,11 +567,11 @@ class QueueManager {
     const queueItem = {
       id: `item-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
       addedAt: new Date().toISOString(),
-      status: 'pending',
-      priority: item.priority || 'normal',
+      status: "pending",
+      priority: item.priority || "normal",
       filePath: item.filePath,
       metadata: item.metadata || {},
-      ...item
+      ...item,
     };
 
     this.queue.items.push(queueItem);
@@ -573,7 +585,7 @@ class QueueManager {
    * @returns {boolean} Whether item was removed
    */
   async removeItem(id) {
-    const index = this.queue.items.findIndex(item => item.id === id);
+    const index = this.queue.items.findIndex((item) => item.id === id);
     if (index === -1) return false;
 
     this.queue.items.splice(index, 1);
@@ -588,7 +600,7 @@ class QueueManager {
    * @param {Object} [extra] - Additional data to merge
    */
   async updateItemStatus(id, status, extra = {}) {
-    const item = this.queue.items.find(i => i.id === id);
+    const item = this.queue.items.find((i) => i.id === id);
     if (item) {
       item.status = status;
       item.updatedAt = new Date().toISOString();
@@ -604,7 +616,7 @@ class QueueManager {
   getPendingItems() {
     const priorityOrder = { high: 0, normal: 1, low: 2 };
     return this.queue.items
-      .filter(item => item.status === 'pending')
+      .filter((item) => item.status === "pending")
       .sort((a, b) => {
         const pA = priorityOrder[a.priority] ?? 1;
         const pB = priorityOrder[b.priority] ?? 1;
@@ -624,14 +636,15 @@ class QueueManager {
       processing: 0,
       completed: 0,
       failed: 0,
-      byPriority: { high: 0, normal: 0, low: 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 (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]++;
@@ -648,7 +661,7 @@ class QueueManager {
   async clearCompleted() {
     const before = this.queue.items.length;
     this.queue.items = this.queue.items.filter(
-      item => !['completed', 'published'].includes(item.status)
+      (item) => !["completed", "published"].includes(item.status),
     );
     await this.save();
     return before - this.queue.items.length;
@@ -671,78 +684,80 @@ class PlatformPublisher {
   initializePlatforms() {
     // WordPress publisher
     this.platforms.set(PLATFORMS.WORDPRESS, {
-      name: 'WordPress',
+      name: "WordPress",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.WORDPRESS,
-          endpoint: 'wp-json/wp/v2/posts'
+          endpoint: "wp-json/wp/v2/posts",
         });
       },
       validateConfig: () => {
-        return !!(process.env.WORDPRESS_URL && process.env.WORDPRESS_APP_PASSWORD);
-      }
+        return !!(
+          process.env.WORDPRESS_URL && process.env.WORDPRESS_APP_PASSWORD
+        );
+      },
     });
 
     // PayloadCMS publisher
     this.platforms.set(PLATFORMS.PAYLOADCMS, {
-      name: 'PayloadCMS',
+      name: "PayloadCMS",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.PAYLOADCMS,
-          endpoint: 'api/posts'
+          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',
+      name: "Static",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.STATIC,
-          outputDir: this.config.staticOutputDir || './content'
+          outputDir: this.config.staticOutputDir || "./content",
         });
       },
-      validateConfig: () => true
+      validateConfig: () => true,
     });
 
     // Docusaurus
     this.platforms.set(PLATFORMS.DOCUSAURUS, {
-      name: 'Docusaurus',
+      name: "Docusaurus",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.DOCUSAURUS,
-          outputDir: this.config.docusaurusDir || './docs'
+          outputDir: this.config.docusaurusDir || "./docs",
         });
       },
-      validateConfig: () => true
+      validateConfig: () => true,
     });
 
     // Mintlify
     this.platforms.set(PLATFORMS.MINTLIFY, {
-      name: 'Mintlify',
+      name: "Mintlify",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.MINTLIFY,
-          outputDir: this.config.mintlifyDir || './docs'
+          outputDir: this.config.mintlifyDir || "./docs",
         });
       },
-      validateConfig: () => true
+      validateConfig: () => true,
     });
 
     // Astro
     this.platforms.set(PLATFORMS.ASTRO, {
-      name: 'Astro',
+      name: "Astro",
       publish: async (item, publishFn) => {
         return publishFn(item, {
           platform: PLATFORMS.ASTRO,
-          outputDir: this.config.astroDir || './src/content'
+          outputDir: this.config.astroDir || "./src/content",
         });
       },
-      validateConfig: () => true
+      validateConfig: () => true,
     });
   }
 
@@ -752,7 +767,10 @@ class PlatformPublisher {
    * @returns {Object|null} Platform publisher
    */
   getPublisher(platform) {
-    return this.platforms.get(platform) || this.platforms.get(this.config.defaultPlatform);
+    return (
+      this.platforms.get(platform) ||
+      this.platforms.get(this.config.defaultPlatform)
+    );
   }
 
   /**
@@ -805,7 +823,7 @@ class CronHelper {
     try {
       // Check if lock file exists and is stale
       try {
-        const lockData = await fs.readFile(this.lockPath, 'utf8');
+        const lockData = await fs.readFile(this.lockPath, "utf8");
         const lock = JSON.parse(lockData);
 
         // Check if lock is stale (older than 1 hour)
@@ -813,31 +831,35 @@ class CronHelper {
         const maxAge = 60 * 60 * 1000; // 1 hour
 
         if (lockAge > maxAge) {
-          console.error('[CronHelper] Stale lock detected, removing...');
+          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}`);
+            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;
+        if (err.code !== "ENOENT") throw err;
       }
 
       // Create lock file
       const lockData = {
         pid: process.pid,
         timestamp: new Date().toISOString(),
-        hostname: os.hostname()
+        hostname: os.hostname(),
       };
 
-      await fs.writeFile(this.lockPath, JSON.stringify(lockData, null, 2), { flag: 'wx' });
+      await fs.writeFile(this.lockPath, JSON.stringify(lockData, null, 2), {
+        flag: "wx",
+      });
       return true;
     } catch (err) {
-      if (err.code === 'EEXIST') {
+      if (err.code === "EEXIST") {
         // Another process created the lock first
         return false;
       }
@@ -853,8 +875,8 @@ class CronHelper {
     try {
       await fs.unlink(this.lockPath);
     } catch (err) {
-      if (err.code !== 'ENOENT') {
-        console.error('[CronHelper] Error releasing lock:', err.message);
+      if (err.code !== "ENOENT") {
+        console.error("[CronHelper] Error releasing lock:", err.message);
       }
     }
   }
@@ -869,19 +891,21 @@ class CronHelper {
     }
 
     try {
-      const data = await fs.readFile(this.lastRunPath, 'utf8');
+      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);
+        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') {
+      if (err.code === "ENOENT") {
         // No last run file, first run
         return { canRun: true, nextRunTime: null, lastRun: null };
       }
@@ -902,8 +926,8 @@ class CronHelper {
         total: results.stats?.totalItems || 0,
         published: results.stats?.published || 0,
         failed: results.stats?.failed || 0,
-        duration: results.duration
-      }
+        duration: results.duration,
+      },
     };
 
     await fs.writeFile(this.lastRunPath, JSON.stringify(runInfo, null, 2));
@@ -915,10 +939,10 @@ class CronHelper {
    */
   async getLastRun() {
     try {
-      const data = await fs.readFile(this.lastRunPath, 'utf8');
+      const data = await fs.readFile(this.lastRunPath, "utf8");
       return JSON.parse(data);
     } catch (err) {
-      if (err.code === 'ENOENT') return null;
+      if (err.code === "ENOENT") return null;
       throw err;
     }
   }
@@ -930,15 +954,16 @@ class CronHelper {
    */
   generateCrontabEntry(options = {}) {
     const {
-      schedule = '0 */6 * * *', // Default: every 6 hours
+      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 = ''
+      contentDir = "content-queue",
+      logFile = "/var/log/content-production-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();
+    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)}
@@ -946,7 +971,7 @@ class CronHelper {
 ${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
+# ${schedule} ${user} /usr/bin/flock -n /tmp/content-production-coordinator.lock ${command} >> ${logFile} 2>&1
 `;
   }
 
@@ -956,23 +981,23 @@ ${schedule} ${user} ${command} >> ${logFile} 2>&1
    * @returns {string} Human-readable description
    */
   describeCronSchedule(schedule) {
-    const parts = schedule.split(' ');
+    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';
+    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;
   }
@@ -984,35 +1009,35 @@ ${schedule} ${user} ${command} >> ${logFile} 2>&1
   getSuggestedSchedules() {
     return [
       {
-        name: 'High frequency',
-        schedule: '*/30 * * * *',
-        description: 'Every 30 minutes - for time-sensitive content'
+        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: "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: "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: "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: "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'
-      }
+        name: "Weekly",
+        schedule: "0 9 * * 1",
+        description: "Every Monday at 9:00 AM - weekly content drops",
+      },
     ];
   }
 
@@ -1027,16 +1052,16 @@ ${schedule} ${user} ${command} >> ${logFile} 2>&1
     if (parts.length !== 5) {
       return {
         valid: false,
-        error: `Expected 5 fields (minute hour day month weekday), got ${parts.length}`
+        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 }
+      { 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++) {
@@ -1044,32 +1069,47 @@ ${schedule} ${user} ${command} >> ${logFile} 2>&1
       const range = ranges[i];
 
       // Skip wildcards
-      if (part === '*') continue;
+      if (part === "*") continue;
 
       // Check step values (*/n)
-      if (part.startsWith('*/')) {
+      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}` };
+          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}` };
+      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));
+      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}` };
+            return {
+              valid: false,
+              error: `Invalid value in ${range.name} list: ${val}`,
+            };
           }
         }
         continue;
@@ -1078,7 +1118,10 @@ ${schedule} ${user} ${command} >> ${logFile} 2>&1
       // 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: false,
+          error: `Invalid ${range.name}: ${part} (must be ${range.min}-${range.max})`,
+        };
       }
     }
 
@@ -1110,14 +1153,19 @@ class ScheduleManager {
   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);
+      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) {
+    if (
+      this.config.defaultPublishDelay === 0 &&
+      this.config.publishSpreadInterval === 0
+    ) {
       return new Date(); // Now
     }
 
@@ -1127,7 +1175,9 @@ class ScheduleManager {
 
     // Apply spread interval if configured
     if (this.config.publishSpreadInterval > 0) {
-      baseTime.setHours(baseTime.getHours() + (index * this.config.publishSpreadInterval));
+      baseTime.setHours(
+        baseTime.getHours() + index * this.config.publishSpreadInterval,
+      );
     }
 
     return baseTime;
@@ -1142,9 +1192,9 @@ class ScheduleManager {
     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 "future";
     }
-    return 'publish';
+    return "publish";
   }
 
   /**
@@ -1171,8 +1221,8 @@ class ScheduleManager {
       useWordPressScheduling: this.config.useWordPressScheduling,
       publishDate: this.formatForWordPress(publishDate),
       status: status,
-      isScheduled: status === 'future',
-      scheduledFor: publishDate.toLocaleString()
+      isScheduled: status === "future",
+      scheduledFor: publishDate.toLocaleString(),
     };
   }
 
@@ -1188,7 +1238,7 @@ class ScheduleManager {
       url: result.url,
       scheduledFor: scheduleContext.publishDate,
       status: scheduleContext.status,
-      platform: item.metadata.target_platform
+      platform: item.metadata.target_platform,
     });
   }
 
@@ -1197,17 +1247,20 @@ class ScheduleManager {
    * @returns {Object} Scheduling summary
    */
   getSummary() {
-    const immediate = this.scheduledPosts.filter(p => p.status === 'publish');
-    const future = this.scheduledPosts.filter(p => p.status === 'future');
+    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
+      nextScheduled:
+        future.length > 0
+          ? future.sort(
+              (a, b) => new Date(a.scheduledFor) - new Date(b.scheduledFor),
+            )[0]
+          : null,
     };
   }
 
@@ -1235,14 +1288,14 @@ Generated: ${new Date().toISOString()}
 |-------|---------------|----------|
 `;
       const futurePosts = this.scheduledPosts
-        .filter(p => p.status === 'future')
+        .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';
+      report += "\n";
     }
 
     if (summary.publishedImmediately > 0) {
@@ -1251,7 +1304,9 @@ Generated: ${new Date().toISOString()}
 | Title | URL | Platform |
 |-------|-----|----------|
 `;
-      const immediatePosts = this.scheduledPosts.filter(p => p.status === 'publish');
+      const immediatePosts = this.scheduledPosts.filter(
+        (p) => p.status === "publish",
+      );
 
       for (const post of immediatePosts) {
         report += `| ${post.title} | ${post.url} | ${post.platform} |\n`;
@@ -1282,7 +1337,7 @@ class ContentCoordinator {
     this.analytics = new AnalyticsTracker();
     this.webhook = new WebhookNotifier(this.config);
     this.queue = new QueueManager(
-      path.join(this.config.outputDir, this.config.queueFileName)
+      path.join(this.config.outputDir, this.config.queueFileName),
     );
     this.publisher = new PlatformPublisher(this.config);
     this.cronHelper = new CronHelper(this.config);
@@ -1293,7 +1348,7 @@ class ContentCoordinator {
       onPhaseChange: null,
       onItemComplete: null,
       onError: null,
-      onConfirmationNeeded: null
+      onConfirmationNeeded: null,
     };
   }
 
@@ -1311,12 +1366,12 @@ class ContentCoordinator {
         ready: [],
         needsReview: [],
         failed: [],
-        published: []
+        published: [],
       },
       reports: {
         readyForPublishing: null,
         needsReview: null,
-        analytics: null
+        analytics: null,
       },
       stats: {
         totalItems: 0,
@@ -1324,11 +1379,11 @@ class ContentCoordinator {
         ready: 0,
         needsReview: 0,
         published: 0,
-        failed: 0
+        failed: 0,
       },
       errors: [],
       checkpoints: [],
-      contentRulesLoaded: false
+      contentRulesLoaded: false,
     };
   }
 
@@ -1345,15 +1400,18 @@ class ContentCoordinator {
    * @returns {Promise<boolean>} Whether state was loaded
    */
   async loadCheckpoint() {
-    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    const statePath = path.join(
+      this.config.outputDir,
+      this.config.stateFileName,
+    );
     try {
-      const data = await fs.readFile(statePath, 'utf8');
+      const data = await fs.readFile(statePath, "utf8");
       this.state = JSON.parse(data);
-      this.log('Loaded checkpoint from', statePath);
+      this.log("Loaded checkpoint from", statePath);
       return true;
     } catch (err) {
-      if (err.code !== 'ENOENT') {
-        this.logError('Error loading checkpoint:', err.message);
+      if (err.code !== "ENOENT") {
+        this.logError("Error loading checkpoint:", err.message);
       }
       return false;
     }
@@ -1364,19 +1422,22 @@ class ContentCoordinator {
    * @returns {Promise<void>}
    */
   async saveCheckpoint() {
-    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    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 }
+      stats: { ...this.state.stats },
     });
 
     try {
       await fs.writeFile(statePath, JSON.stringify(this.state, null, 2));
-      this.log('Saved checkpoint to', statePath);
+      this.log("Saved checkpoint to", statePath);
     } catch (err) {
-      this.logError('Error saving checkpoint:', err.message);
+      this.logError("Error saving checkpoint:", err.message);
     }
   }
 
@@ -1385,13 +1446,16 @@ class ContentCoordinator {
    * @returns {Promise<void>}
    */
   async clearCheckpoint() {
-    const statePath = path.join(this.config.outputDir, this.config.stateFileName);
+    const statePath = path.join(
+      this.config.outputDir,
+      this.config.stateFileName,
+    );
     try {
       await fs.unlink(statePath);
-      this.log('Cleared checkpoint file');
+      this.log("Cleared checkpoint file");
     } catch (err) {
-      if (err.code !== 'ENOENT') {
-        this.logError('Error clearing checkpoint:', err.message);
+      if (err.code !== "ENOENT") {
+        this.logError("Error clearing checkpoint:", err.message);
       }
     }
   }
@@ -1404,22 +1468,22 @@ class ContentCoordinator {
     // 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')
+      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.log("Loaded content rules from", rulesPath);
         this.state.contentRulesLoaded = true;
         return;
       }
     }
 
-    this.log('No content-rules.md found, proceeding without brand voice rules');
+    this.log("No content-rules.md found, proceeding without brand voice rules");
   }
 
   /**
@@ -1428,17 +1492,17 @@ class ContentCoordinator {
    * @returns {Promise<Object>} Parsed content item
    */
   async parseContentFile(filePath) {
-    const content = await fs.readFile(filePath, 'utf8');
+    const content = await fs.readFile(filePath, "utf8");
     const item = {
       id: path.basename(filePath, path.extname(filePath)),
       filePath,
       status: ITEM_STATUS.PENDING,
       metadata: {},
-      content: '',
+      content: "",
       verification: null,
       publishedUrl: null,
       errors: [],
-      timing: {}
+      timing: {},
     };
 
     // Parse YAML front matter
@@ -1449,14 +1513,17 @@ class ContentCoordinator {
       item.content = frontMatterMatch[2].trim();
 
       // Parse front matter fields
-      const lines = frontMatter.split('\n');
+      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, '');
+          const value = line
+            .replace(/^\s+-\s+/, "")
+            .trim()
+            .replace(/^["']|["']$/g, "");
           if (!Array.isArray(item.metadata[currentKey])) {
             item.metadata[currentKey] = [];
           }
@@ -1465,13 +1532,17 @@ class ContentCoordinator {
         }
 
         arrayMode = false;
-        const colonIndex = line.indexOf(':');
+        const colonIndex = line.indexOf(":");
         if (colonIndex > 0) {
-          const key = line.slice(0, colonIndex).trim().toLowerCase().replace(/\s+/g, '_');
+          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 === '[]') {
+          if (value === "" || value === "[]") {
             currentKey = key;
             arrayMode = true;
             item.metadata[key] = [];
@@ -1479,8 +1550,10 @@ class ContentCoordinator {
           }
 
           // Remove quotes if present
-          if ((value.startsWith('"') && value.endsWith('"')) ||
-              (value.startsWith("'") && value.endsWith("'"))) {
+          if (
+            (value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))
+          ) {
             value = value.slice(1, -1);
           }
 
@@ -1500,31 +1573,86 @@ class ContentCoordinator {
     }
 
     // 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';
+    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 ||
+      item.metadata.publish ||
+      this.config.defaultPlatform;
+    item.metadata.priority = item.metadata.priority || "normal";
+    item.metadata.mode = item.metadata.mode || "new";
+
+    // Extract job directory context from file path (e.g. content-queue/job20260223_01/)
+    const parentDir = path.basename(path.dirname(filePath));
+    if (/^job\d{8}_\d{2}$/.test(parentDir) || /^job\d{8,14}$/.test(parentDir)) {
+      item.metadata.jobDir = parentDir;
+    }
 
     return item;
   }
 
   /**
-   * Discover content files in work directory
+   * Discover content files recursively in work directory and job subdirectories
    * @returns {Promise<string[]>} Array of file paths
    */
   async discoverContentFiles() {
     const files = [];
-    const entries = await fs.readdir(this.workDir, { withFileTypes: true });
+    await this._scanDirectory(this.workDir, files);
+    return files.sort((a, b) => {
+      const dirA = path.dirname(a);
+      const dirB = path.dirname(b);
+      if (dirA !== dirB) return dirA.localeCompare(dirB);
+      return a.localeCompare(b);
+    });
+  }
+
+  /**
+   * Recursively scan a directory for markdown content files
+   * @param {string} dir - Directory to scan
+   * @param {string[]} files - Accumulator array
+   * @returns {Promise<void>}
+   */
+  async _scanDirectory(dir, files) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return;
+      throw err;
+    }
+
+    const EXCLUDED_DIRS = new Set([
+      "node_modules",
+      ".git",
+      ".claude",
+      ".gemini",
+      ".codex",
+      ".agents",
+      "dist",
+      "build",
+      "coverage",
+      "vendor",
+      "skills",
+      "agents",
+      ".myaidev-method",
+      ".content-session",
+      "platforms",
+    ]);
 
     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));
+      if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRS.has(entry.name)) {
+          await this._scanDirectory(fullPath, files);
+        }
+      } else if (entry.isFile() && /\.(md|markdown)$/i.test(entry.name)) {
+        files.push(fullPath);
       }
     }
-
-    return files.sort();
   }
 
   /**
@@ -1558,7 +1686,7 @@ class ContentCoordinator {
           status: ITEM_STATUS.FAILED,
           metadata: { title: path.basename(filePath) },
           errors: [err.message],
-          timing: {}
+          timing: {},
         });
       }
     }
@@ -1571,7 +1699,7 @@ class ContentCoordinator {
     await this.webhook.notifyStart({
       totalItems: this.state.stats.totalItems,
       workDir: this.workDir,
-      contentRulesLoaded: this.state.contentRulesLoaded
+      contentRulesLoaded: this.state.contentRulesLoaded,
     });
 
     await this.saveCheckpoint();
@@ -1587,10 +1715,12 @@ class ContentCoordinator {
     this.analytics.startPhase(PHASES.VERIFY);
 
     const pendingItems = this.state.items.filter(
-      item => item.status === ITEM_STATUS.PENDING
+      (item) => item.status === ITEM_STATUS.PENDING,
     );
 
-    this.log(`Verifying ${pendingItems.length} items with concurrency ${this.config.concurrency}`);
+    this.log(
+      `Verifying ${pendingItems.length} items with concurrency ${this.config.concurrency}`,
+    );
 
     // Get content rules context for verification
     const rulesContext = this.contentRules.getVerificationContext();
@@ -1599,37 +1729,41 @@ class ContentCoordinator {
     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 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();
     }
@@ -1656,12 +1790,15 @@ class ContentCoordinator {
       }
 
       const verification = item.verification || {};
-      const score = (verification.redundancyScore || '').toLowerCase();
-      const recommendation = (verification.recommendation || '').toLowerCase();
+      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');
+      const isLowRedundancy = [
+        REDUNDANCY_THRESHOLDS.MINIMAL,
+        REDUNDANCY_THRESHOLDS.LOW,
+      ].includes(score);
+      const isProceedRecommended = recommendation.includes("proceed");
 
       if (isLowRedundancy && isProceedRecommended) {
         item.status = ITEM_STATUS.READY;
@@ -1693,23 +1830,26 @@ class ContentCoordinator {
       const readyReport = this.generateReadyReport(timestamp);
       const readyPath = path.join(
         this.config.outputDir,
-        `ready-for-publishing-${timestamp}.md`
+        `ready-for-publishing-${timestamp}.md`,
       );
       await fs.writeFile(readyPath, readyReport);
       this.state.reports.readyForPublishing = readyPath;
-      this.log('Generated report:', readyPath);
+      this.log("Generated report:", readyPath);
     }
 
     // Generate Needs Review report
-    if (this.state.results.needsReview.length > 0 || this.state.results.failed.length > 0) {
+    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`
+        `needs-review-${timestamp}.md`,
       );
       await fs.writeFile(reviewPath, reviewReport);
       this.state.reports.needsReview = reviewPath;
-      this.log('Generated report:', reviewPath);
+      this.log("Generated report:", reviewPath);
     }
 
     // Generate analytics report if enabled
@@ -1717,11 +1857,11 @@ class ContentCoordinator {
       const analyticsReport = this.generateAnalyticsReport(timestamp);
       const analyticsPath = path.join(
         this.config.outputDir,
-        `analytics-${timestamp}.md`
+        `analytics-${timestamp}.md`,
       );
       await fs.writeFile(analyticsPath, analyticsReport);
       this.state.reports.analytics = analyticsPath;
-      this.log('Generated analytics report:', analyticsPath);
+      this.log("Generated analytics report:", analyticsPath);
     }
 
     this.analytics.endPhase(PHASES.REPORT);
@@ -1740,21 +1880,21 @@ class ContentCoordinator {
         total: this.state.stats.totalItems,
         ready: this.state.stats.ready,
         needsReview: this.state.stats.needsReview,
-        failed: this.state.stats.failed
+        failed: this.state.stats.failed,
       },
       reports: this.state.reports,
-      readyItems: this.state.results.ready.map(item => ({
+      readyItems: this.state.results.ready.map((item) => ({
         title: item.metadata.title,
         score: item.verification?.redundancyScore,
         recommendation: item.verification?.recommendation,
-        platform: item.metadata.target_platform
+        platform: item.metadata.target_platform,
       })),
-      needsReviewItems: this.state.results.needsReview.map(item => ({
+      needsReviewItems: this.state.results.needsReview.map((item) => ({
         title: item.metadata.title,
         score: item.verification?.redundancyScore,
-        reason: item.verification?.feedback || 'Requires manual review'
+        reason: item.verification?.feedback || "Requires manual review",
       })),
-      contentRulesApplied: this.state.contentRulesLoaded
+      contentRulesApplied: this.state.contentRulesLoaded,
     };
   }
 
@@ -1765,7 +1905,7 @@ class ContentCoordinator {
    */
   async phasePublish(publishFn) {
     if (this.config.dryRun) {
-      this.log('Dry run mode - skipping publish phase');
+      this.log("Dry run mode - skipping publish phase");
       this.setPhase(PHASES.COMPLETE);
       return;
     }
@@ -1774,99 +1914,110 @@ class ContentCoordinator {
     this.analytics.startPhase(PHASES.PUBLISH);
 
     const readyItems = this.state.results.ready.filter(
-      item => item.status === ITEM_STATUS.READY
+      (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}`);
+    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.SCHEDULED : 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 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.SCHEDULED
+              : 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();
     }
@@ -1888,18 +2039,26 @@ class ContentCoordinator {
       const lockAcquired = await this.cronHelper.acquireLock();
       if (!lockAcquired) {
         if (!this.config.quietMode) {
-          console.log('[ContentCoordinator] Another instance is running, exiting');
+          console.log(
+            "[ContentCoordinator] Another instance is running, exiting",
+          );
         }
-        return { skipped: true, reason: 'lock_held' };
+        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}`);
+          console.log(
+            `[ContentCoordinator] Minimum interval not met, next run at ${intervalCheck.nextRunTime}`,
+          );
         }
-        return { skipped: true, reason: 'interval_not_met', nextRunTime: intervalCheck.nextRunTime };
+        return {
+          skipped: true,
+          reason: "interval_not_met",
+          nextRunTime: intervalCheck.nextRunTime,
+        };
       }
     }
 
@@ -1915,26 +2074,44 @@ class ContentCoordinator {
         await this.phaseInitialize();
       }
 
-      if (this.state.phase === PHASES.INITIALIZE || this.state.phase === PHASES.VERIFY) {
+      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)) {
+      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)) {
+      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 (
+        !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.log("Publishing cancelled by user");
             this.analytics.endWorkflow();
             if (this.config.cronMode) {
               await this.cronHelper.releaseLock();
@@ -1969,14 +2146,13 @@ class ContentCoordinator {
       }
 
       return results;
-
     } catch (err) {
-      this.logError('Workflow error:', err.message);
+      this.logError("Workflow error:", err.message);
       this.analytics.endWorkflow();
       await this.saveCheckpoint();
       await this.webhook.notifyError({
         error: err.message,
-        phase: this.state.phase
+        phase: this.state.phase,
       });
 
       // Cron mode: release lock on error
@@ -1997,22 +2173,24 @@ class ContentCoordinator {
       success: this.state.stats.failed === 0,
       stats: this.state.stats,
       reports: this.state.reports,
-      published: this.state.results.published.map(item => ({
+      published: this.state.results.published.map((item) => ({
         title: item.metadata.title,
         url: item.publishedUrl,
-        platform: item.metadata.target_platform
+        platform: item.metadata.target_platform,
       })),
-      needsReview: this.state.results.needsReview.map(item => ({
+      needsReview: this.state.results.needsReview.map((item) => ({
         title: item.metadata.title,
-        reason: item.verification?.feedback || 'Requires review'
+        reason: item.verification?.feedback || "Requires review",
       })),
-      failed: this.state.results.failed.map(item => ({
+      failed: this.state.results.failed.map((item) => ({
         title: item.metadata.title,
-        errors: item.errors
+        errors: item.errors,
       })),
       duration: this.calculateDuration(),
-      analytics: this.config.enableAnalytics ? this.analytics.getSummary() : null,
-      contentRulesApplied: this.state.contentRulesLoaded
+      analytics: this.config.enableAnalytics
+        ? this.analytics.getSummary()
+        : null,
+      contentRulesApplied: this.state.contentRulesLoaded,
     };
   }
 
@@ -2034,7 +2212,7 @@ Generated: ${this.formatTimestamp(timestamp)}
 - 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'}
+- Content Rules Applied: ${this.state.contentRulesLoaded ? "Yes" : "No"}
 
 ## Items
 
@@ -2044,12 +2222,12 @@ Generated: ${this.formatTimestamp(timestamp)}
       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'}
+- **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'}
+- **Verifier Feedback**: ${v.feedback || "No feedback provided"}
+- **Target Platform**: ${item.metadata.target_platform || "wordpress"}
+- **Priority**: ${item.metadata.priority || "normal"}
 
 `;
     });
@@ -2084,10 +2262,10 @@ Generated: ${this.formatTimestamp(timestamp)}
         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'}
+- **Redundancy Score**: ${v.redundancyScore || "N/A"}
+- **Recommendation**: ${v.recommendation || "N/A"}
 - **Issue**: ${this.getReviewReason(item)}
-- **Verifier Feedback**: ${v.feedback || 'No feedback provided'}
+- **Verifier Feedback**: ${v.feedback || "No feedback provided"}
 - **Suggested Actions**:
   - Review and revise proprietary content
   - Ensure content adds unique value
@@ -2105,7 +2283,7 @@ Generated: ${this.formatTimestamp(timestamp)}
         report += `### ${index + 1}. ${item.metadata.title}
 - **File**: ${path.basename(item.filePath)}
 - **Errors**:
-${item.errors.map(e => `  - ${e}`).join('\n')}
+${item.errors.map((e) => `  - ${e}`).join("\n")}
 - **Suggested Actions**:
   - Review file format and content
   - Fix any parsing errors
@@ -2182,15 +2360,17 @@ Generated: ${this.formatTimestamp(timestamp)}
    */
   getReviewReason(item) {
     const v = item.verification || {};
-    const score = (v.redundancyScore || '').toLowerCase();
-    const rec = (v.recommendation || '').toLowerCase();
+    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';
+    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';
+    return "Content requires attention before publishing";
   }
 
   /**
@@ -2204,20 +2384,20 @@ Generated: ${this.formatTimestamp(timestamp)}
     let count = 0;
 
     for (const item of items) {
-      const score = (item.verification?.redundancyScore || '').toLowerCase();
+      const score = (item.verification?.redundancyScore || "").toLowerCase();
       if (scores[score]) {
         total += scores[score];
         count++;
       }
     }
 
-    if (count === 0) return 'N/A';
+    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';
+    if (avg <= 1.5) return "Minimal";
+    if (avg <= 2.5) return "Low";
+    if (avg <= 3.5) return "Medium";
+    return "High";
   }
 
   /**
@@ -2234,7 +2414,10 @@ Generated: ${this.formatTimestamp(timestamp)}
       } catch (err) {
         lastError = err;
         if (attempt < this.config.retryAttempts) {
-          this.log(`Retry attempt ${attempt}/${this.config.retryAttempts} after error:`, err.message);
+          this.log(
+            `Retry attempt ${attempt}/${this.config.retryAttempts} after error:`,
+            err.message,
+          );
           await this.sleep(this.config.retryDelay * attempt);
         }
       }
@@ -2282,7 +2465,7 @@ Generated: ${this.formatTimestamp(timestamp)}
     this.state.errors.push({
       item: item.metadata.title,
       error: error.message,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     });
 
     if (this.callbacks.onError) {
@@ -2296,10 +2479,11 @@ Generated: ${this.formatTimestamp(timestamp)}
    */
   getTimestamp() {
     const now = new Date();
-    return now.toISOString()
-      .replace(/T/, '-')
-      .replace(/:/g, '-')
-      .replace(/\..+/, '');
+    return now
+      .toISOString()
+      .replace(/T/, "-")
+      .replace(/:/g, "-")
+      .replace(/\..+/, "");
   }
 
   /**
@@ -2308,7 +2492,9 @@ Generated: ${this.formatTimestamp(timestamp)}
    * @returns {string} Human-readable timestamp
    */
   formatTimestamp(timestamp) {
-    return timestamp.replace(/-/g, (m, i) => i > 9 ? ':' : '-').replace('-', ' ');
+    return timestamp
+      .replace(/-/g, (m, i) => (i > 9 ? ":" : "-"))
+      .replace("-", " ");
   }
 
   /**
@@ -2316,7 +2502,7 @@ Generated: ${this.formatTimestamp(timestamp)}
    * @returns {string} Duration string
    */
   calculateDuration() {
-    if (!this.state.startedAt) return 'N/A';
+    if (!this.state.startedAt) return "N/A";
 
     const start = new Date(this.state.startedAt);
     const end = new Date();
@@ -2337,7 +2523,7 @@ Generated: ${this.formatTimestamp(timestamp)}
    * @returns {Promise<void>}
    */
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   /**
@@ -2346,7 +2532,7 @@ Generated: ${this.formatTimestamp(timestamp)}
    */
   log(...args) {
     if (this.config.verbose) {
-      console.log('[ContentCoordinator]', ...args);
+      console.log("[ContentCoordinator]", ...args);
     }
   }
 
@@ -2355,7 +2541,7 @@ Generated: ${this.formatTimestamp(timestamp)}
    * @param {...*} args - Error arguments
    */
   logError(...args) {
-    console.error('[ContentCoordinator Error]', ...args);
+    console.error("[ContentCoordinator Error]", ...args);
   }
 
   // ============================================
@@ -2416,7 +2602,7 @@ Generated: ${this.formatTimestamp(timestamp)}
   generateCrontabEntry(options = {}) {
     return this.cronHelper.generateCrontabEntry({
       workDir: this.workDir || process.cwd(),
-      ...options
+      ...options,
     });
   }
 
@@ -2506,10 +2692,14 @@ ${entry}
 
 ## Suggested Schedules
 
-${schedules.map(s => `### ${s.name}
+${schedules
+  .map(
+    (s) => `### ${s.name}
 # ${s.description}
 # Schedule: ${s.schedule}
-`).join('\n')}
+`,
+  )
+  .join("\n")}
 
 ## Environment Variables
 
@@ -2520,9 +2710,9 @@ Make sure these are set in your crontab or script:
 
 ## Log Rotation (optional)
 
-Add to /etc/logrotate.d/content-coordinator:
+Add to /etc/logrotate.d/content-production-coordinator:
 \`\`\`
-/var/log/content-coordinator.log {
+/var/log/content-production-coordinator.log {
     weekly
     rotate 4
     compress
@@ -2537,7 +2727,7 @@ After adding, verify with:
    crontab -l
 
 Check logs at:
-   tail -f /var/log/content-coordinator.log
+   tail -f /var/log/content-production-coordinator.log
 `;
   }
 }
@@ -2556,7 +2746,7 @@ export {
   ITEM_STATUS,
   REDUNDANCY_THRESHOLDS,
   PLATFORMS,
-  DEFAULT_CONFIG
+  DEFAULT_CONFIG,
 };
 
 // Default export for convenience