@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/orchestration/task-complexity-classifier.js

@@ -0,0 +1,253 @@
+'use strict';
+
+/**
+ * Task Complexity Classifier — Model selection via task complexity scoring.
+ * Part of AIOS Core: copy-chief/orchestration
+ *
+ * Maps task descriptions and context signals to a complexity level,
+ * which drives model selection for cost/quality optimization.
+ *
+ * Complexity levels:
+ *   simple  (<0.3)  → haiku  — status checks, reads, lists, routing
+ *   medium  (0.3–0.7) → sonnet — research, validation, criativos, LP blocks
+ *   complex (>0.7)  → opus   — VSL production, briefing, strategy, HELIX
+ *
+ * Scoring:
+ *   - Keyword scoring (simple vs. complex vocabulary)
+ *   - Context signals (file count, deliverable type, multi-offer flag)
+ *   - Phase complexity baseline
+ *
+ * Usage:
+ *   const { classify, getModelRecommendation } = require('./task-complexity-classifier');
+ *   const result = classify('produce full VSL script', { phase: 'production', deliverableType: 'vsl' });
+ *   // → { level: 'complex', confidence: 0.85, recommended_model: 'claude-opus-4-6' }
+ *
+ * @module task-complexity-classifier
+ * @version 1.0.0
+ */
+
+// ─── Keyword scoring ──────────────────────────────────────────────────────────
+
+/**
+ * Words associated with simple tasks. Each match contributes negatively to score.
+ */
+const SIMPLE_KEYWORDS = [
+  'check', 'list', 'read', 'status', 'show', 'display', 'get', 'fetch',
+  'view', 'look', 'find', 'count', 'verify', 'confirm', 'scan', 'report',
+  'summary', 'describe', 'summarize', 'print',
+];
+
+/**
+ * Words associated with complex tasks. Each match contributes positively to score.
+ */
+const COMPLEX_KEYWORDS = [
+  'create', 'produce', 'write', 'generate', 'build', 'design', 'develop',
+  'analyze', 'research', 'strategy', 'optimize', 'orchestrate', 'synthesize',
+  'brief', 'briefing', 'helix', 'mecanismo', 'vsl', 'copywrite', 'script',
+  'persona', 'avatar', 'mechanism', 'persuasion', 'emotional', 'funnel',
+  'multi', 'comprehensive', 'complete', 'full', 'entire', 'all',
+];
+
+/**
+ * Words that moderately increase complexity.
+ */
+const MEDIUM_KEYWORDS = [
+  'validate', 'review', 'evaluate', 'assess', 'critique', 'compare',
+  'plan', 'draft', 'outline', 'structure', 'organize', 'update',
+  'refine', 'improve', 'edit', 'revise', 'adapt', 'translate',
+];
+
+// ─── Phase baseline scores ────────────────────────────────────────────────────
+
+/**
+ * Base complexity score contributed by the pipeline phase.
+ */
+const PHASE_COMPLEXITY = {
+  research:   0.45,
+  briefing:   0.70,
+  mecanismo:  0.65,
+  production: 0.70,
+  review:     0.45,
+  delivery:   0.30,
+  setup:      0.20,
+};
+
+// ─── Deliverable type scores ──────────────────────────────────────────────────
+
+/**
+ * Additional complexity from deliverable type.
+ * VSL is the most complex deliverable in the Copy Chief pipeline.
+ */
+const DELIVERABLE_COMPLEXITY = {
+  vsl:          0.30,
+  landing_page: 0.15,
+  lp:           0.15,
+  email:        0.10,
+  criativo:     0.10,
+  creative:     0.10,
+  checklist:    0.05,
+  report:       0.05,
+};
+
+// ─── Model mapping ────────────────────────────────────────────────────────────
+
+/**
+ * Model recommendations per complexity level.
+ * Model IDs match the squad CLAUDE.md routing table.
+ */
+const MODEL_MAP = {
+  simple:  'claude-haiku-4',
+  medium:  'claude-sonnet-4-6',
+  complex: 'claude-opus-4-6',
+};
+
+/**
+ * Complexity level thresholds.
+ */
+const THRESHOLDS = {
+  simple_max:  0.30,
+  complex_min: 0.70,
+};
+
+// ─── classify ─────────────────────────────────────────────────────────────────
+
+/**
+ * Classify a task description into a complexity level.
+ *
+ * @param {string} taskDescription - Free-text task description
+ * @param {object} [context={}]
+ * @param {string}   [context.phase]           - Pipeline phase name
+ * @param {string}   [context.deliverableType] - Deliverable type
+ * @param {number}   [context.fileCount]       - Number of files involved
+ * @param {boolean}  [context.multiOffer]      - Task spans multiple offers
+ * @returns {{ level: 'simple'|'medium'|'complex', confidence: number, recommended_model: string, score: number, signals: string[] }}
+ */
+function classify(taskDescription, context = {}) {
+  const desc = String(taskDescription || '').toLowerCase();
+  const words = desc.split(/\s+/).filter(Boolean);
+
+  const signals = [];
+  let score = 0;
+
+  // ── Keyword scoring ──────────────────────────────────────────────────────
+
+  let simpleHits = 0;
+  let complexHits = 0;
+  let mediumHits = 0;
+
+  for (const word of words) {
+    if (SIMPLE_KEYWORDS.some(kw => word.includes(kw))) simpleHits++;
+    if (COMPLEX_KEYWORDS.some(kw => word.includes(kw))) complexHits++;
+    if (MEDIUM_KEYWORDS.some(kw => word.includes(kw))) mediumHits++;
+  }
+
+  // Normalize keyword contribution (max ±0.35)
+  const keywordNet = (complexHits * 0.12) - (simpleHits * 0.08) + (mediumHits * 0.04);
+  const keywordContrib = Math.max(-0.35, Math.min(0.35, keywordNet));
+  score += keywordContrib;
+
+  if (complexHits > 0) signals.push(`complex keywords: ${complexHits}`);
+  if (simpleHits > 0) signals.push(`simple keywords: ${simpleHits}`);
+  if (mediumHits > 0) signals.push(`medium keywords: ${mediumHits}`);
+
+  // ── Phase baseline ────────────────────────────────────────────────────────
+
+  const { phase, deliverableType, fileCount, multiOffer } = context;
+
+  if (phase) {
+    const phaseScore = PHASE_COMPLEXITY[phase.toLowerCase()];
+    if (phaseScore !== undefined) {
+      // Phase contributes up to 0.40 (scaled from baseline, not additive)
+      const phaseContrib = phaseScore * 0.40;
+      score += phaseContrib;
+      signals.push(`phase(${phase}): +${phaseContrib.toFixed(2)}`);
+    }
+  } else {
+    // No phase: apply neutral baseline
+    score += 0.15;
+  }
+
+  // ── Deliverable type signal ───────────────────────────────────────────────
+
+  if (deliverableType) {
+    const normalized = deliverableType.toLowerCase().replace(/-/g, '_');
+    const delivContrib = DELIVERABLE_COMPLEXITY[normalized];
+    if (delivContrib !== undefined) {
+      score += delivContrib;
+      signals.push(`deliverable(${deliverableType}): +${delivContrib.toFixed(2)}`);
+    }
+  }
+
+  // ── Context signals ───────────────────────────────────────────────────────
+
+  if (fileCount && typeof fileCount === 'number') {
+    if (fileCount > 10) {
+      score += 0.10;
+      signals.push(`file count(${fileCount}): +0.10`);
+    } else if (fileCount > 3) {
+      score += 0.05;
+      signals.push(`file count(${fileCount}): +0.05`);
+    }
+  }
+
+  if (multiOffer === true) {
+    score += 0.15;
+    signals.push('multi-offer: +0.15');
+  }
+
+  // ── Clamp to [0, 1] ───────────────────────────────────────────────────────
+
+  const finalScore = Math.max(0, Math.min(1, score));
+
+  // ── Level and confidence ──────────────────────────────────────────────────
+
+  let level;
+  let confidence;
+
+  if (finalScore < THRESHOLDS.simple_max) {
+    level = 'simple';
+    // Higher confidence the further below simple_max
+    confidence = Math.round((1 - finalScore / THRESHOLDS.simple_max) * 0.7 + 0.3, 2);
+  } else if (finalScore >= THRESHOLDS.complex_min) {
+    level = 'complex';
+    confidence = Math.round(Math.min(1, (finalScore - THRESHOLDS.complex_min) / (1 - THRESHOLDS.complex_min) * 0.7 + 0.3), 2);
+  } else {
+    level = 'medium';
+    const midpoint = (THRESHOLDS.simple_max + THRESHOLDS.complex_min) / 2;
+    confidence = Math.round(1 - Math.abs(finalScore - midpoint) / midpoint * 0.5, 2);
+  }
+
+  confidence = Math.max(0.1, Math.min(1, confidence));
+
+  return {
+    level,
+    confidence: Math.round(confidence * 100) / 100,
+    recommended_model: MODEL_MAP[level],
+    score: Math.round(finalScore * 100) / 100,
+    signals,
+  };
+}
+
+// ─── getModelRecommendation ───────────────────────────────────────────────────
+
+/**
+ * Convenience wrapper: returns just the recommended model string.
+ *
+ * @param {string} taskDescription
+ * @param {object} [context={}]
+ * @returns {string} model ID
+ */
+function getModelRecommendation(taskDescription, context = {}) {
+  return classify(taskDescription, context).recommended_model;
+}
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  classify,
+  getModelRecommendation,
+  MODEL_MAP,
+  THRESHOLDS,
+  PHASE_COMPLEXITY,
+  DELIVERABLE_COMPLEXITY,
+};

package/framework/.aios-core/copy-chief/plan/execution-plan-generator.js

@@ -0,0 +1,355 @@
+'use strict';
+
+/**
+ * Execution Plan Generator
+ *
+ * Converts Workflow YAML + helix-state.yaml into a concrete execution-plan.yaml
+ * with numbered tasks, waves, checkpoints, and verification rules.
+ *
+ * Reuses CopyWorkflowExecutor.loadWorkflow() and CopyPromptBuilder.buildDispatchPayload().
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+const ECOSYSTEM_ROOT = path.join(process.env.HOME, 'copywriting-ecosystem');
+const WORKFLOWS_DIR = path.join(ECOSYSTEM_ROOT, 'squads', 'copy-chief', 'workflows');
+
+// Maps task types to verification rules
+const TASK_VERIFICATION_MAP = {
+  'produce-vsl': { type: 'dir_has_files', path: 'production/vsl/' },
+  'produce-landing-page': { type: 'dir_has_files', path: 'production/landing-page/' },
+  'produce-creatives': { type: 'dir_has_files', path: 'production/creatives/' },
+  'produce-emails': { type: 'dir_has_files', path: 'production/emails/' },
+  'validate-deliverable': { type: 'file_exists', path: 'production/review-results.md' },
+  'voc-extraction': { type: 'file_exists', path: 'research/voc/summary.md' },
+  'competitor-analysis': { type: 'file_exists', path: 'research/competitors/summary.md' },
+  'avatar-profiling': { type: 'file_exists', path: 'research/avatar/summary.md' },
+  'helix-briefing': { type: 'dir_has_files', path: 'briefings/phases/' },
+  'validate-mecanismo': { type: 'file_exists', path: 'mecanismo-unico.yaml' },
+};
+
+// Gate names that trigger automatic checkpoints after completion
+const CHECKPOINT_AFTER_GATES = ['blind_critic', 'black_validation', 'emotional_stress_test'];
+
+class ExecutionPlanGenerator {
+  constructor(ecosystemRoot) {
+    this.ecosystemRoot = ecosystemRoot || ECOSYSTEM_ROOT;
+    this.workflowsDir = path.join(this.ecosystemRoot, 'squads', 'copy-chief', 'workflows');
+  }
+
+  /**
+   * Generate an execution plan from a workflow YAML + offer state.
+   * @param {string} offerPath - Relative offer path (e.g. "saude/florayla")
+   * @param {string} workflowId - Workflow ID (e.g. "production-pipeline")
+   * @returns {object} The execution plan object
+   */
+  generate(offerPath, workflowId) {
+    const workflowPath = path.join(this.workflowsDir, `${workflowId}.yaml`);
+    if (!fs.existsSync(workflowPath)) {
+      throw new Error(`Workflow not found: ${workflowPath}`);
+    }
+
+    const content = yaml.load(fs.readFileSync(workflowPath, 'utf8'));
+    const workflow = content?.workflow;
+    if (!workflow) {
+      throw new Error(`Invalid workflow format in ${workflowPath}`);
+    }
+
+    // Load CopyPromptBuilder for 7-layer prompts
+    const { CopyPromptBuilder } = require(
+      path.join(process.env.HOME, '.claude', '.aios-core', 'copy-chief', 'execution', 'copy-prompt-builder')
+    );
+    const promptBuilder = new CopyPromptBuilder(this.ecosystemRoot);
+
+    // Load helix-state for skip detection
+    const helixState = this._loadHelixState(offerPath);
+
+    const now = new Date().toISOString();
+    const plan = {
+      plan_id: `${workflowId}-${Date.now()}`,
+      offer: offerPath,
+      workflow: workflowId,
+      status: 'pending',
+      created_at: now,
+      updated_at: now,
+      current_task: null,
+      tasks: [],
+      decisions: [],
+      context: '',
+    };
+
+    const phases = workflow.phases || [];
+    let taskId = 0;
+    let currentWave = 0;
+    const phaseToWaveMap = {};
+
+    // First pass: assign waves based on dependencies and parallel flags
+    const phaseOrder = this._resolvePhaseOrder(phases);
+
+    for (const phase of phaseOrder) {
+      // Determine wave number
+      const deps = phase.depends_on || [];
+      let wave;
+      if (deps.length > 0) {
+        // Wave = max wave of deps + 1
+        const depWaves = deps.map(d => phaseToWaveMap[d] || 0);
+        wave = Math.max(...depWaves) + 1;
+      } else if (phase.parallel) {
+        // Parallel phases without deps share wave with adjacent parallel phases
+        wave = currentWave;
+      } else {
+        wave = currentWave;
+      }
+
+      phaseToWaveMap[phase.id] = wave;
+
+      // Check if phase is human_gate → becomes checkpoint
+      if (phase.human_gate) {
+        taskId++;
+        const depTaskIds = this._getDependentTaskIds(plan.tasks, deps);
+        plan.tasks.push({
+          id: taskId,
+          type: 'checkpoint',
+          checkpoint_type: 'human-verify',
+          wave,
+          title: phase.title || `Gate: ${phase.id}`,
+          description: phase.handoff_prompt || 'Verificar antes de prosseguir.',
+          resume_signal: 'approved ou descreva problemas',
+          depends_on: depTaskIds.length > 0 ? depTaskIds : undefined,
+          status: 'pending',
+        });
+        currentWave = wave + 1;
+        continue;
+      }
+
+      // Build agent tasks from phase
+      const agents = phase.agents || [];
+      const tasks = phase.tasks || [];
+
+      for (let i = 0; i < agents.length; i++) {
+        const agentId = agents[i];
+        const taskType = tasks[i] || phase.id;
+
+        // Check if already completed (skip)
+        if (this._isTaskCompleted(taskType, offerPath, helixState)) {
+          taskId++;
+          plan.tasks.push({
+            id: taskId,
+            type: 'auto',
+            wave,
+            agent: agentId,
+            model: this._getAgentModel(agentId),
+            title: phase.title || taskType,
+            prompt: '', // skipped, no prompt needed
+            expected_outputs: this._getExpectedOutputs(taskType, offerPath),
+            verification: TASK_VERIFICATION_MAP[taskType] || null,
+            depends_on: undefined,
+            status: 'skipped',
+            skipped_reason: 'Already completed (detected from filesystem/helix-state)',
+          });
+          continue;
+        }
+
+        // Build 7-layer prompt via CopyPromptBuilder
+        const syntheticPhase = {
+          id: phase.id,
+          title: phase.title || taskType,
+          agents: [agentId],
+          tasks: [taskType],
+          handoff_prompt: phase.handoff_prompt,
+        };
+
+        const payloads = promptBuilder.buildDispatchPayload(syntheticPhase, offerPath);
+        const payload = payloads[0];
+
+        if (!payload) continue;
+
+        const depTaskIds = this._getDependentTaskIds(plan.tasks, deps);
+
+        taskId++;
+        plan.tasks.push({
+          id: taskId,
+          type: 'auto',
+          wave,
+          agent: agentId,
+          model: payload.model,
+          title: phase.title || taskType,
+          prompt: payload.prompt,
+          expected_outputs: payload.expectedOutputs || [],
+          verification: TASK_VERIFICATION_MAP[taskType] || null,
+          depends_on: depTaskIds.length > 0 ? depTaskIds : undefined,
+          status: 'pending',
+        });
+      }
+
+      // Insert checkpoint after review phases (quality gate phases)
+      if (phase.id.includes('review') || phase.id.includes('gate')) {
+        taskId++;
+        plan.tasks.push({
+          id: taskId,
+          type: 'checkpoint',
+          checkpoint_type: 'human-verify',
+          wave: wave + 1,
+          title: `Verificar: ${phase.title || phase.id}`,
+          description: `Review/gate completo. Verificar resultados antes de prosseguir.`,
+          resume_signal: 'approved ou descreva problemas',
+          depends_on: [taskId - 1],
+          status: 'pending',
+        });
+      }
+
+      currentWave = wave + 1;
+    }
+
+    // Set current_task to first pending
+    const firstPending = plan.tasks.find(t => t.status === 'pending');
+    plan.current_task = firstPending ? firstPending.id : null;
+
+    if (plan.current_task) {
+      plan.status = 'executing';
+    }
+
+    return plan;
+  }
+
+  /**
+   * Save execution plan to {offer}/.aios/execution-plan.yaml
+   */
+  save(offerPath, plan) {
+    const aiosDir = path.join(this.ecosystemRoot, offerPath, '.aios');
+    fs.mkdirSync(aiosDir, { recursive: true });
+    const planPath = path.join(aiosDir, 'execution-plan.yaml');
+    plan.updated_at = new Date().toISOString();
+    fs.writeFileSync(planPath, yaml.dump(plan, { lineWidth: 120, noRefs: true }), 'utf8');
+    return planPath;
+  }
+
+  /**
+   * Load execution plan from {offer}/.aios/execution-plan.yaml
+   */
+  load(offerPath) {
+    const planPath = path.join(this.ecosystemRoot, offerPath, '.aios', 'execution-plan.yaml');
+    if (!fs.existsSync(planPath)) return null;
+    try {
+      return yaml.load(fs.readFileSync(planPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  // --- Private helpers ---
+
+  _resolvePhaseOrder(phases) {
+    // Topological sort respecting depends_on
+    const resolved = [];
+    const resolvedIds = new Set();
+    const remaining = [...phases];
+    let maxIterations = phases.length * 2;
+
+    while (remaining.length > 0 && maxIterations-- > 0) {
+      const next = remaining.findIndex(p => {
+        const deps = p.depends_on || [];
+        return deps.every(d => resolvedIds.has(d));
+      });
+
+      if (next === -1) {
+        // Circular dep or unresolvable — push remaining as-is
+        resolved.push(...remaining);
+        break;
+      }
+
+      const phase = remaining.splice(next, 1)[0];
+      resolved.push(phase);
+      resolvedIds.add(phase.id);
+    }
+
+    return resolved;
+  }
+
+  _getDependentTaskIds(existingTasks, depPhaseIds) {
+    if (!depPhaseIds || depPhaseIds.length === 0) return [];
+    // Find task IDs that belong to the dependent phases
+    const ids = [];
+    for (const task of existingTasks) {
+      // Match by title containing the phase id, or by the task being in the same wave group
+      for (const depId of depPhaseIds) {
+        if (task.title && task.title.toLowerCase().includes(depId.replace(/-/g, ' ').toLowerCase())) {
+          ids.push(task.id);
+        }
+      }
+    }
+    return [...new Set(ids)];
+  }
+
+  _loadHelixState(offerPath) {
+    const helixPath = path.join(this.ecosystemRoot, offerPath, 'helix-state.yaml');
+    if (!fs.existsSync(helixPath)) return {};
+    try {
+      return yaml.load(fs.readFileSync(helixPath, 'utf8')) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  _isTaskCompleted(taskType, offerPath, helixState) {
+    const verification = TASK_VERIFICATION_MAP[taskType];
+    if (!verification) return false;
+
+    const offerDir = path.join(this.ecosystemRoot, offerPath);
+
+    switch (verification.type) {
+      case 'dir_has_files':
+        return this._hasFiles(path.join(offerDir, verification.path));
+      case 'file_exists':
+        return fs.existsSync(path.join(offerDir, verification.path));
+      case 'gate_passed':
+        return helixState?.gates?.[verification.gate]?.passed === true;
+      default:
+        return false;
+    }
+  }
+
+  _hasFiles(dirPath) {
+    try {
+      if (!fs.existsSync(dirPath)) return false;
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile()) return true;
+        if (entry.isDirectory()) {
+          if (this._hasFiles(path.join(dirPath, entry.name))) return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  _getExpectedOutputs(taskType, offerPath) {
+    const map = {
+      'produce-vsl': [`${offerPath}/production/vsl/`],
+      'produce-landing-page': [`${offerPath}/production/landing-page/`],
+      'produce-creatives': [`${offerPath}/production/creatives/`],
+      'produce-emails': [`${offerPath}/production/emails/`],
+      'validate-deliverable': [`${offerPath}/production/review-results.md`],
+      'voc-extraction': [`${offerPath}/research/voc/summary.md`],
+      'competitor-analysis': [`${offerPath}/research/competitors/summary.md`],
+      'avatar-profiling': [`${offerPath}/research/avatar/summary.md`],
+      'helix-briefing': [`${offerPath}/briefings/phases/`],
+    };
+    return map[taskType] || [];
+  }
+
+  _getAgentModel(agentId) {
+    const models = {
+      vox: 'sonnet', cipher: 'sonnet', atlas: 'opus',
+      echo: 'opus', forge: 'sonnet', scout: 'sonnet',
+      blade: 'sonnet', hawk: 'sonnet', sentinel: 'sonnet',
+    };
+    return models[agentId] || 'sonnet';
+  }
+}
+
+module.exports = { ExecutionPlanGenerator, TASK_VERIFICATION_MAP };