@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/health/manifest-validator.js

@@ -0,0 +1,156 @@
+'use strict';
+
+/**
+ * Manifest Validator
+ *
+ * Validates .synapse/manifest against actual .synapse/ files.
+ * Checks bidirectional consistency: manifest entries have files, files have entries.
+ *
+ * @module manifest-validator
+ * @version 1.0.0
+ * @atom U-02
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Validate manifest consistency.
+ *
+ * Checks:
+ * 1. Every DOMAIN_STATE=active has matching .synapse/{domain} file
+ * 2. Every .synapse/ domain file has manifest entry
+ * 3. AGENT_TRIGGER domains match agents/ directory
+ * 4. WORKFLOW_TRIGGER domains match workflows/ directory
+ *
+ * @param {string} synapsePath - Path to .synapse/ directory
+ * @param {object} options
+ * @param {string} [options.agentsDir] - Path to agents/ directory
+ * @returns {{ valid: boolean, warnings: string[], errors: string[] }}
+ */
+function validateManifest(synapsePath, options = {}) {
+  const result = { valid: true, warnings: [], errors: [] };
+
+  const manifestPath = path.join(synapsePath, 'manifest');
+  if (!fs.existsSync(manifestPath)) {
+    result.errors.push('manifest file not found');
+    result.valid = false;
+    return result;
+  }
+
+  // Parse manifest
+  const manifest = parseManifest(fs.readFileSync(manifestPath, 'utf8'));
+
+  // Get actual .synapse/ files (excluding dirs and special files)
+  const SKIP_ENTRIES = new Set(['manifest', 'metrics', 'sessions', 'star-commands', 'commands', 'constitution']);
+  let synapseFiles;
+  try {
+    synapseFiles = fs.readdirSync(synapsePath, { withFileTypes: true })
+      .filter(e => !e.isDirectory() || !SKIP_ENTRIES.has(e.name))
+      .filter(e => !e.name.startsWith('.') && !SKIP_ENTRIES.has(e.name))
+      .map(e => e.name);
+  } catch {
+    result.errors.push('cannot read .synapse/ directory');
+    result.valid = false;
+    return result;
+  }
+
+  // Check 1: Active domains have matching files
+  for (const [domain, state] of Object.entries(manifest.domains)) {
+    if (state !== 'active') continue;
+    const domainFile = domain.toLowerCase().replace(/_/g, '-');
+    if (!synapseFiles.includes(domainFile)) {
+      result.warnings.push(`Domain ${domain} is active in manifest but no .synapse/${domainFile} file`);
+    }
+  }
+
+  // Check 2: Synapse files have manifest entries
+  const manifestDomainFiles = new Set(
+    Object.keys(manifest.domains).map(d => d.toLowerCase().replace(/_/g, '-'))
+  );
+  const manifestAgentFiles = new Set(
+    Object.keys(manifest.agentTriggers).map(a => `agent-${a.toLowerCase()}`)
+  );
+  const manifestWorkflowFiles = new Set(
+    Object.keys(manifest.workflowTriggers).map(w => `workflow-${w.toLowerCase().replace(/_/g, '-')}`)
+  );
+  const allManifestFiles = new Set([...manifestDomainFiles, ...manifestAgentFiles, ...manifestWorkflowFiles]);
+
+  for (const file of synapseFiles) {
+    if (!allManifestFiles.has(file)) {
+      result.warnings.push(`File .synapse/${file} exists but has no manifest entry`);
+    }
+  }
+
+  // Check 3: Agent triggers match agents/ directory
+  const agentsDir = options.agentsDir || path.join(process.env.HOME, '.claude', 'agents');
+  if (fs.existsSync(agentsDir)) {
+    for (const agentName of Object.keys(manifest.agentTriggers)) {
+      const agentFile = path.join(agentsDir, `${agentName}.md`);
+      const agentDir = path.join(agentsDir, agentName);
+      if (!fs.existsSync(agentFile) && !fs.existsSync(agentDir)) {
+        result.warnings.push(`Agent trigger ${agentName} has no matching agent file`);
+      }
+    }
+  }
+
+  // Check 4: Workflow triggers match workflow files
+  for (const workflowName of Object.keys(manifest.workflowTriggers)) {
+    const wfFile = `workflow-${workflowName.replace(/_/g, '-')}`;
+    if (!synapseFiles.includes(wfFile)) {
+      result.warnings.push(`Workflow trigger ${workflowName} has no .synapse/${wfFile} file`);
+    }
+  }
+
+  if (result.errors.length > 0) result.valid = false;
+  return result;
+}
+
+/**
+ * Parse manifest KEY=VALUE format.
+ * @param {string} content
+ * @returns {{ domains: Object, agentTriggers: Object, workflowTriggers: Object, raw: Object }}
+ */
+function parseManifest(content) {
+  const raw = {};
+  const domains = {};
+  const agentTriggers = {};
+  const workflowTriggers = {};
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx < 0) continue;
+
+    const key = trimmed.substring(0, eqIdx).trim();
+    const value = trimmed.substring(eqIdx + 1).trim();
+    raw[key] = value;
+
+    // Domain states: {NAME}_STATE=active
+    const domainMatch = key.match(/^([A-Z_]+)_STATE$/);
+    if (domainMatch && !key.includes('AGENT_TRIGGER') && !key.includes('WORKFLOW_TRIGGER')) {
+      const name = domainMatch[1];
+      // Skip agent/workflow state entries
+      if (!raw[`${name}_AGENT_TRIGGER`] && !raw[`${name}_WORKFLOW_TRIGGER`]) {
+        domains[name] = value;
+      }
+    }
+
+    // Agent triggers: {NAME}_AGENT_TRIGGER=id
+    const agentMatch = key.match(/^([A-Z_]+)_AGENT_TRIGGER$/);
+    if (agentMatch) {
+      agentTriggers[value] = agentMatch[1];
+    }
+
+    // Workflow triggers: {NAME}_WORKFLOW_TRIGGER=id
+    const wfMatch = key.match(/^([A-Z_]+)_WORKFLOW_TRIGGER$/);
+    if (wfMatch) {
+      workflowTriggers[value] = wfMatch[1];
+    }
+  }
+
+  return { domains, agentTriggers, workflowTriggers, raw };
+}
+
+module.exports = { validateManifest, parseManifest };

package/framework/.aios-core/copy-chief/ids/mcp-circuit-breaker.js

@@ -0,0 +1,246 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+// Import base CircuitBreaker from AIOS Core
+const { CircuitBreaker, STATE_CLOSED, STATE_OPEN, STATE_HALF_OPEN } = require(
+  path.join(__dirname, '..', '..', 'core', 'ids', 'circuit-breaker')
+);
+
+const DEFAULT_STATE_PATH = path.join(
+  process.env.HOME, '.claude', '.aios-core', 'copy-chief', 'state', 'circuit-breakers.json'
+);
+
+const PROTECTED_TOOLS = [
+  'mcp__copywriting__blind_critic',
+  'mcp__copywriting__emotional_stress_test',
+  'mcp__copywriting__validate_gate',
+  'mcp__copywriting__black_validation',
+  'mcp__copywriting__voc_search',
+  'mcp__copywriting__write_chapter',
+  'mcp__copywriting__layered_review',
+  'mcp__copywriting__create_mecanismo',
+  'mcp__copywriting__get_phase_context',
+  'mcp__firecrawl__firecrawl_agent',
+  'mcp__firecrawl__firecrawl_scrape',
+  'mcp__firecrawl__firecrawl_search',
+  'mcp__zen__consensus',
+  'mcp__zen__thinkdeep',
+  'mcp__zen__challenge',
+  'mcp__zen__codereview',
+  'mcp__fb_ad_library__get_meta_ads',
+  'mcp__fb_ad_library__analyze_ad_video',
+  'mcp__apify__call-actor',
+  'mcp__apify__get-dataset-items',
+];
+
+const DEFAULT_OPTIONS = {
+  failureThreshold: 5,
+  successThreshold: 3,
+  resetTimeoutMs: 60000,
+};
+
+class MCPCircuitBreakerRegistry {
+  constructor(options = {}) {
+    this.options = {
+      ...DEFAULT_OPTIONS,
+      statePath: DEFAULT_STATE_PATH,
+      debug: false,
+      ...options,
+    };
+
+    this._breakers = new Map();
+    this._protectedTools = new Set(options.protectedTools || PROTECTED_TOOLS);
+  }
+
+  getBreaker(toolName) {
+    if (!this._breakers.has(toolName)) {
+      this._breakers.set(toolName, new CircuitBreaker({
+        failureThreshold: this.options.failureThreshold,
+        successThreshold: this.options.successThreshold,
+        resetTimeoutMs: this.options.resetTimeoutMs,
+      }));
+    }
+    return this._breakers.get(toolName);
+  }
+
+  isProtected(toolName) {
+    return this._protectedTools.has(toolName);
+  }
+
+  recordSuccess(toolName) {
+    if (!this.isProtected(toolName)) return;
+    const breaker = this.getBreaker(toolName);
+    breaker.recordSuccess();
+    this._log(`SUCCESS: ${toolName} — state: ${breaker.getState()}`);
+  }
+
+  recordFailure(toolName) {
+    if (!this.isProtected(toolName)) return;
+    const breaker = this.getBreaker(toolName);
+    const previousState = breaker.getState();
+    breaker.recordFailure();
+    const newState = breaker.getState();
+
+    this._log(`FAILURE: ${toolName} — ${previousState} -> ${newState}`);
+
+    if (previousState !== STATE_OPEN && newState === STATE_OPEN) {
+      this._log(`CIRCUIT OPENED: ${toolName} after ${this.options.failureThreshold} consecutive failures`);
+    }
+  }
+
+  isAllowed(toolName) {
+    if (!this.isProtected(toolName)) return { allowed: true, reason: 'not_protected' };
+
+    const breaker = this.getBreaker(toolName);
+    const allowed = breaker.isAllowed();
+    const state = breaker.getState();
+
+    if (!allowed) {
+      const stats = breaker.getStats();
+      return {
+        allowed: false,
+        reason: 'circuit_open',
+        state,
+        failureCount: stats.failureCount,
+        totalTrips: stats.totalTrips,
+        lastFailureTime: stats.lastFailureTime,
+        message: this._buildWarningMessage(toolName, stats),
+      };
+    }
+
+    return {
+      allowed: true,
+      reason: state === STATE_HALF_OPEN ? 'half_open_probe' : 'circuit_closed',
+      state,
+    };
+  }
+
+  getStatus() {
+    const status = {};
+    for (const [toolName, breaker] of this._breakers) {
+      status[toolName] = breaker.getStats();
+    }
+    return status;
+  }
+
+  getOpenCircuits() {
+    const open = [];
+    for (const [toolName, breaker] of this._breakers) {
+      const state = breaker.getState();
+      if (state === STATE_OPEN || state === STATE_HALF_OPEN) {
+        open.push({
+          tool: toolName,
+          state,
+          stats: breaker.getStats(),
+        });
+      }
+    }
+    return open;
+  }
+
+  persist(statePath) {
+    const targetPath = statePath || this.options.statePath;
+    const state = {};
+
+    for (const [toolName, breaker] of this._breakers) {
+      state[toolName] = breaker.getStats();
+    }
+
+    try {
+      const dir = path.dirname(targetPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(targetPath, JSON.stringify({
+        version: '1.0',
+        timestamp: new Date().toISOString(),
+        breakers: state,
+      }, null, 2), 'utf8');
+      this._log(`State persisted to ${targetPath}`);
+    } catch (e) {
+      this._log(`Failed to persist state: ${e.message}`);
+    }
+  }
+
+  restore(statePath) {
+    const targetPath = statePath || this.options.statePath;
+
+    if (!fs.existsSync(targetPath)) {
+      this._log('No persisted state found');
+      return false;
+    }
+
+    try {
+      const content = fs.readFileSync(targetPath, 'utf8');
+      const data = JSON.parse(content);
+
+      if (!data.breakers) return false;
+
+      // Only restore failure counts, not states (let circuit breaker recalculate)
+      for (const [toolName, stats] of Object.entries(data.breakers)) {
+        if (this.isProtected(toolName)) {
+          const breaker = this.getBreaker(toolName);
+          // If tool had recent failures, pre-seed the failure count
+          if (stats.failureCount > 0) {
+            const timeSinceLastFailure = Date.now() - (stats.lastFailureTime || 0);
+            // Only restore if failure was within last 5 minutes
+            if (timeSinceLastFailure < 300000) {
+              for (let i = 0; i < stats.failureCount; i++) {
+                breaker.recordFailure();
+              }
+              this._log(`Restored ${toolName}: ${stats.failureCount} failures`);
+            }
+          }
+        }
+      }
+
+      return true;
+    } catch (e) {
+      this._log(`Failed to restore state: ${e.message}`);
+      return false;
+    }
+  }
+
+  reset(toolName) {
+    if (toolName) {
+      const breaker = this._breakers.get(toolName);
+      if (breaker) breaker.reset();
+    } else {
+      for (const breaker of this._breakers.values()) {
+        breaker.reset();
+      }
+    }
+  }
+
+  _buildWarningMessage(toolName, stats) {
+    const shortName = toolName.replace('mcp__copywriting__', '').replace('mcp__', '');
+    const resetIn = Math.max(0, Math.ceil(
+      (this.options.resetTimeoutMs - (Date.now() - stats.lastFailureTime)) / 1000
+    ));
+
+    return [
+      `⚠️ CIRCUIT BREAKER OPEN: ${shortName}`,
+      `${stats.failureCount} falhas consecutivas (threshold: ${this.options.failureThreshold}).`,
+      `Circuito reabre em ~${resetIn}s para probe.`,
+      `Trips totais: ${stats.totalTrips}.`,
+      `Ação sugerida: verificar se o MCP server está respondendo.`,
+    ].join(' ');
+  }
+
+  _log(message) {
+    if (this.options.debug) {
+      console.log(`[MCPCircuitBreaker] ${message}`);
+    }
+  }
+}
+
+module.exports = {
+  MCPCircuitBreakerRegistry,
+  PROTECTED_TOOLS,
+  DEFAULT_OPTIONS,
+  STATE_CLOSED,
+  STATE_OPEN,
+  STATE_HALF_OPEN,
+};

package/framework/.aios-core/copy-chief/index.js

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * Copy Chief OS — Module Index
+ *
+ * Orchestration layer that transforms Copy Chief from
+ * prompt-based routing to deterministic JS-controlled OS.
+ *
+ * @module copy-chief
+ * @version 1.0.0
+ */
+
+// Orchestration
+const { HelixOrchestrator, OfferPhase, AGENT_MAP, WORKFLOW_MAP, ROUTING_TABLE } = require('./orchestration/helix-orchestrator');
+const { OfferScanner, KNOWN_NICHES } = require('./orchestration/offer-scanner');
+const { DELIVERABLE_ASSIGNMENT_TABLE, getDeliverableType, assignPersonaFromPath, validateAssignment } = require('./orchestration/deliverable-assignment');
+
+// Execution
+const { CopyWorkflowExecutor, ExecutionState } = require('./execution/copy-workflow-executor');
+const { CopyPromptBuilder, AGENT_MODELS } = require('./execution/copy-prompt-builder');
+const { analyzeWaves, getCriticalPath, getOptimizationGain, detectCycles } = require('./execution/wave-analyzer');
+
+// Workflow Intelligence
+const { getSuggestions, getTopSuggestion, invalidateCache } = require('./workflow/suggestion-engine');
+const { calculateConfidence, scoreGateStatus, scoreFileCompleteness } = require('./workflow/confidence-scorer');
+const { capturePattern, getPatterns, getFrequentSequences, prunePatterns } = require('./workflow/pattern-capture');
+
+// Activation
+const { AgentActivationPipeline } = require('./activation/agent-activation-pipeline');
+const { KnowledgeLoader } = require('./activation/knowledge-loader');
+
+// IDS (Intrusion Detection / Circuit Breakers)
+const { MCPCircuitBreakerRegistry, PROTECTED_TOOLS } = require('./ids/mcp-circuit-breaker');
+
+// Handoff
+const { HandoffProtocol, HandoffStatus, AGENT_HANDOFF_MAP } = require('./handoff/handoff-protocol');
+
+// Lifecycle
+const { CopyDataLifecycle } = require('./lifecycle/copy-data-lifecycle');
+
+// Observability
+const { CopyStatusWriter, COPY_PIPELINE_STAGES } = require('./observability/copy-status-writer');
+
+// Dispatch (Gap 1, 2, 3)
+const { DispatchQueueManager, DispatchStatus } = require('./dispatch/dispatch-queue-manager');
+
+// Memory (Gap 4 + PreCompact)
+const { AgentMemoryManager, MEMORY_CAPS, VALID_MEMORY_TYPES } = require('./memory/agent-memory-manager');
+const { IndexUpdater } = require('./memory/index-updater');
+const { SessionDigestExtractor } = require('./memory/session-digest-extractor');
+const { compactAgent, compactAll } = require('./memory/memory-compactor');
+
+// Learning (enhanced)
+const { registerGotcha, queryRelevant, formatForAgent, pruneGotchas, getStats: getGotchaStats } = require('./learning/gotcha-registry');
+
+// Plan (LLM-as-CPU)
+const { ExecutionPlanGenerator, TASK_VERIFICATION_MAP } = require('./plan/execution-plan-generator');
+const { PlanStateMachine } = require('./plan/plan-state-machine');
+const { PlanVerification } = require('./plan/plan-verification');
+
+module.exports = {
+  // Orchestration
+  HelixOrchestrator,
+  OfferPhase,
+  OfferScanner,
+  AGENT_MAP,
+  WORKFLOW_MAP,
+  ROUTING_TABLE,
+  KNOWN_NICHES,
+  DELIVERABLE_ASSIGNMENT_TABLE,
+  getDeliverableType,
+  assignPersonaFromPath,
+  validateAssignment,
+
+  // Execution
+  CopyWorkflowExecutor,
+  CopyPromptBuilder,
+  ExecutionState,
+  AGENT_MODELS,
+  analyzeWaves,
+  getCriticalPath,
+  getOptimizationGain,
+  detectCycles,
+
+  // Workflow Intelligence
+  getSuggestions,
+  getTopSuggestion,
+  invalidateCache,
+  calculateConfidence,
+  scoreGateStatus,
+  scoreFileCompleteness,
+  capturePattern,
+  getPatterns,
+  getFrequentSequences,
+  prunePatterns,
+
+  // Activation
+  AgentActivationPipeline,
+  KnowledgeLoader,
+
+  // IDS
+  MCPCircuitBreakerRegistry,
+  PROTECTED_TOOLS,
+
+  // Handoff
+  HandoffProtocol,
+  HandoffStatus,
+  AGENT_HANDOFF_MAP,
+
+  // Lifecycle
+  CopyDataLifecycle,
+
+  // Observability
+  CopyStatusWriter,
+  COPY_PIPELINE_STAGES,
+
+  // Dispatch (Gap 1, 2, 3)
+  DispatchQueueManager,
+  DispatchStatus,
+
+  // Memory (Gap 4 + PreCompact)
+  AgentMemoryManager,
+  MEMORY_CAPS,
+  VALID_MEMORY_TYPES,
+  IndexUpdater,
+  SessionDigestExtractor,
+  compactAgent,
+  compactAll,
+
+  // Learning (enhanced)
+  registerGotcha,
+  queryRelevant,
+  formatForAgent,
+  pruneGotchas,
+  getGotchaStats,
+
+  // Plan (LLM-as-CPU)
+  ExecutionPlanGenerator,
+  TASK_VERIFICATION_MAP,
+  PlanStateMachine,
+  PlanVerification,
+};