@lucapimenta/copy-chief-black 1.0.0

package/framework/hooks/pipeline-state-projector.cjs

@@ -0,0 +1,288 @@
+'use strict';
+
+/**
+ * Pipeline State Projector Hook
+ * Event: SubagentStop (after handoff-validator-hook)
+ * Budget: <3s
+ *
+ * Projects helix-state.yaml → pipeline-state.json for dashboard consumption.
+ * Creates or updates pipeline-state.json at the offer root.
+ * Fail-open: never blocks Claude.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const yaml = require('js-yaml');
+
+const CANONICAL_STEPS = [
+  { id: 'research.voc', phase: 'research', description: 'VOC Extraction' },
+  { id: 'research.competitors', phase: 'research', description: 'Competitor Analysis' },
+  { id: 'research.mechanism', phase: 'research', description: 'Mechanism Discovery' },
+  { id: 'research.avatar', phase: 'research', description: 'Avatar Synthesis' },
+  { id: 'research.synthesis', phase: 'research', description: 'Research Synthesis' },
+  { id: 'research.gate', phase: 'research', description: 'Research Gate Validation' },
+  { id: 'briefing.fase_01', phase: 'briefing', description: 'HELIX Fase 1: Analise de Inputs' },
+  { id: 'briefing.fase_02', phase: 'briefing', description: 'HELIX Fase 2: Definicao de Avatar' },
+  { id: 'briefing.fase_03', phase: 'briefing', description: 'HELIX Fase 3: Definicao de DRE' },
+  { id: 'briefing.fase_04', phase: 'briefing', description: 'HELIX Fase 4: Nivel de Consciencia' },
+  { id: 'briefing.fase_05', phase: 'briefing', description: 'HELIX Fase 5: Problema/Vilao/MUP' },
+  { id: 'briefing.fase_06', phase: 'briefing', description: 'HELIX Fase 6: Solucao/MUS' },
+  { id: 'briefing.fase_07', phase: 'briefing', description: 'HELIX Fase 7: Estrutura da Oferta' },
+  { id: 'briefing.fase_08', phase: 'briefing', description: 'HELIX Fase 8: Stack de Valor' },
+  { id: 'briefing.fase_09', phase: 'briefing', description: 'HELIX Fase 9: Garantia e Urgencia' },
+  { id: 'briefing.fase_10', phase: 'briefing', description: 'HELIX Fase 10: Consolidacao' },
+  { id: 'briefing.gate', phase: 'briefing', description: 'Briefing Gate Validation' },
+  { id: 'production.lp', phase: 'production', description: 'Landing Page' },
+  { id: 'production.creatives', phase: 'production', description: 'Criativos' },
+  { id: 'production.vsl', phase: 'production', description: 'VSL Script' },
+  { id: 'production.emails', phase: 'production', description: 'Email Sequence' },
+  { id: 'production.final_validation', phase: 'production', description: 'BLACK Validation Final' },
+];
+
+// Map research deliverables to filesystem markers
+const RESEARCH_FILE_MAP = {
+  'research.voc': 'research/voc/summary.md',
+  'research.competitors': 'research/competitors/summary.md',
+  'research.mechanism': 'research/mechanism/summary.md',
+  'research.avatar': 'research/avatar/summary.md',
+  'research.synthesis': 'research/synthesis.md',
+};
+
+// Map production deliverables to filesystem markers
+const PRODUCTION_FILE_MAP = {
+  'production.lp': 'production/landing-page/',
+  'production.creatives': 'production/creatives/',
+  'production.vsl': 'production/vsl/',
+  'production.emails': 'production/emails/',
+};
+
+async function main() {
+  let input = '';
+  try { input = fs.readFileSync(0, 'utf8'); } catch { return out(); }
+
+  let context = {};
+  try { context = JSON.parse(input); } catch { return out(); }
+
+  const prompt = context.prompt || context.description || '';
+  const offerPath = detectOfferPath(prompt);
+  if (!offerPath) return out();
+
+  const ecosystemRoot = process.env.ECOSYSTEM_ROOT || path.join(process.env.HOME, 'copywriting-ecosystem');
+  const offerDir = path.join(ecosystemRoot, offerPath);
+
+  // === Priority: Project from execution-plan.yaml if present ===
+  const planPath = path.join(offerDir, '.aios', 'execution-plan.yaml');
+  if (fs.existsSync(planPath)) {
+    try {
+      const plan = yaml.load(fs.readFileSync(planPath, 'utf8'));
+      if (plan && plan.tasks) {
+        projectFromPlan(plan, offerPath, offerDir);
+        return out();
+      }
+    } catch { /* fall through to helix-state heuristic */ }
+  }
+
+  // === Fallback: Project from helix-state.yaml ===
+  // Read helix-state.yaml
+  const helixPath = path.join(offerDir, 'helix-state.yaml');
+  if (!fs.existsSync(helixPath)) return out();
+
+  let helix;
+  try { helix = yaml.load(fs.readFileSync(helixPath, 'utf8')); } catch { return out(); }
+  if (!helix) return out();
+
+  const now = new Date().toISOString();
+
+  // Read existing pipeline-state.json (preserve started_at, mode)
+  const pipelinePath = path.join(offerDir, 'pipeline-state.json');
+  let existing = {};
+  try { existing = JSON.parse(fs.readFileSync(pipelinePath, 'utf8')); } catch { /* new file */ }
+
+  // Project steps
+  const completed = [];
+  const remaining = [];
+
+  for (const step of CANONICAL_STEPS) {
+    if (isStepCompleted(step, helix, offerDir)) {
+      completed.push({
+        id: step.id,
+        phase: step.phase,
+        description: step.description,
+        result: 'SUCCESS',
+        details: 'Synced from helix-state.yaml',
+        completed_at: now,
+      });
+    } else {
+      remaining.push(step.id);
+    }
+  }
+
+  // Determine current phase and step
+  const currentStep = remaining[0] || null;
+  const currentPhase = currentStep ? currentStep.split('.')[0] : 'delivered';
+
+  // Determine pipeline status
+  let status = 'IN_PROGRESS';
+  if (remaining.length === 0) status = 'COMPLETED';
+  if (completed.length === 0 && !helix.phase) status = 'IDLE';
+
+  // Build state
+  const state = {
+    offer_path: offerPath,
+    status,
+    current_phase: currentPhase,
+    current_step: currentStep,
+    started_at: existing.started_at || helix.created_at || now,
+    updated_at: now,
+    steps_completed: completed,
+    steps_remaining: remaining,
+    mode: existing.mode || (existing.overnight_mode ? 'overnight' : 'interactive'),
+    _source: 'aios-projection',
+    _generated_by: 'pipeline-state-projector',
+    _generated_at: now,
+  };
+
+  // Write pipeline-state.json
+  try {
+    fs.writeFileSync(pipelinePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  } catch { /* non-critical */ }
+
+  return out();
+}
+
+/**
+ * Project pipeline-state.json from execution-plan.yaml (more precise than heuristic).
+ */
+function projectFromPlan(plan, offerPath, offerDir) {
+  const now = new Date().toISOString();
+  const pipelinePath = path.join(offerDir, 'pipeline-state.json');
+
+  let existing = {};
+  try { existing = JSON.parse(fs.readFileSync(pipelinePath, 'utf8')); } catch { /* new file */ }
+
+  const completed = [];
+  const remaining = [];
+
+  for (const task of plan.tasks) {
+    if (task.status === 'completed' || task.status === 'skipped') {
+      completed.push({
+        id: `plan.task-${task.id}`,
+        phase: plan.workflow || 'unknown',
+        description: task.title || `Task ${task.id}`,
+        result: task.status === 'skipped' ? 'SKIPPED' : 'SUCCESS',
+        details: task.result || task.skipped_reason || 'From execution plan',
+        completed_at: task.completed_at || now,
+      });
+    } else {
+      remaining.push(`plan.task-${task.id}`);
+    }
+  }
+
+  // Determine status
+  let status = 'IN_PROGRESS';
+  if (plan.status === 'completed') status = 'COMPLETED';
+  if (plan.status === 'pending') status = 'IDLE';
+
+  const currentTask = plan.current_task
+    ? plan.tasks.find(t => t.id === plan.current_task)
+    : null;
+
+  const state = {
+    offer_path: offerPath,
+    status,
+    current_phase: plan.workflow || 'unknown',
+    current_step: currentTask ? `plan.task-${currentTask.id}` : null,
+    current_task_title: currentTask?.title || null,
+    current_task_agent: currentTask?.agent || null,
+    started_at: existing.started_at || plan.created_at || now,
+    updated_at: now,
+    steps_completed: completed,
+    steps_remaining: remaining,
+    mode: existing.mode || 'plan-driven',
+    plan_id: plan.plan_id,
+    _source: 'execution-plan',
+    _generated_by: 'pipeline-state-projector',
+    _generated_at: now,
+  };
+
+  try {
+    fs.writeFileSync(pipelinePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
+  } catch { /* non-critical */ }
+}
+
+/**
+ * Check if a step is completed based on helix state + filesystem.
+ */
+function isStepCompleted(step, helix, offerDir) {
+  const gates = helix.gates || {};
+  const phases = helix.helix_phases || {};
+
+  // Research steps
+  if (step.phase === 'research') {
+    // If research gate passed, ALL research steps are done
+    if (gates.research?.passed) return true;
+    // Otherwise check individual deliverable files
+    if (step.id === 'research.gate') return false;
+    const filePath = RESEARCH_FILE_MAP[step.id];
+    if (filePath) {
+      return fs.existsSync(path.join(offerDir, filePath));
+    }
+    return false;
+  }
+
+  // Briefing steps
+  if (step.phase === 'briefing') {
+    // If briefing gate passed, ALL briefing steps are done
+    if (gates.briefing?.passed) return true;
+    if (step.id === 'briefing.gate') return false;
+    // Check individual HELIX phase status
+    const phaseNum = step.id.replace('briefing.fase_', '');
+    const phaseKey = `phase_${parseInt(phaseNum, 10)}`;
+    const phaseState = phases[phaseKey];
+    return phaseState?.status === 'completed' || phaseState?.status === 'approved';
+  }
+
+  // Production steps — check for actual files (not empty scaffold dirs)
+  if (step.phase === 'production') {
+    if (gates.production?.passed) return true;
+    if (step.id === 'production.final_validation') return false;
+    const dirPath = PRODUCTION_FILE_MAP[step.id];
+    if (dirPath) {
+      return hasFiles(path.join(offerDir, dirPath));
+    }
+    return false;
+  }
+
+  return false;
+}
+
+/**
+ * Recursively check if a directory contains at least one real file (not just empty subdirs).
+ */
+function 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 (hasFiles(path.join(dirPath, entry.name))) return true;
+      }
+    }
+    return false;
+  } catch { return false; }
+}
+
+function detectOfferPath(prompt) {
+  const offerMatch = prompt.match(/(?:OFFER|offer|oferta)[:\s]+(?:~\/copywriting-ecosystem\/)?([a-z-]+\/[a-z-]+)/i);
+  if (offerMatch) return offerMatch[1];
+  const pathMatch = prompt.match(/\b(saude|relacionamento|concursos|financeiro|educacao|marketing-digital)\/([a-z][a-z0-9-]+)\b/);
+  if (pathMatch) return `${pathMatch[1]}/${pathMatch[2]}`;
+  return null;
+}
+
+function out() {
+  process.stdout.write(JSON.stringify({}));
+}
+
+main().catch(() => { process.exit(0); });

package/framework/hooks/plan-session-guard.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+/**
+ * Plan Session Guard
+ * Event: PreCompact
+ * Budget: <3s
+ *
+ * Before compact, saves continue-here.yaml if an execution plan is active.
+ * This ensures session continuity across compacts and new sessions.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Writes an enriched continue-here.yaml to targetPath for the given offerPath.
+ * offerPath is relative to ecosystemRoot (e.g. 'saude/florayla').
+ * Exported for testing.
+ */
+function _writeContinueHereToPath(targetPath, offerPath) {
+  const ecosystemRoot = process.env.ECOSYSTEM_ROOT
+    || path.join(process.env.HOME, 'copywriting-ecosystem');
+
+  const yaml = require('js-yaml');
+
+  // --- Base fields ---
+  const doc = {
+    offer: offerPath,
+    phase: null,
+    timestamp: new Date().toISOString(),
+    plan_id: null,
+  };
+
+  // Try to load plan for phase/plan_id
+  const aiosDir = path.join(ecosystemRoot, offerPath, '.aios');
+  const planPath = path.join(aiosDir, 'execution-plan.yaml');
+  try {
+    const plan = yaml.load(fs.readFileSync(planPath, 'utf8'));
+    if (plan) {
+      doc.plan_id = plan.id || null;
+      doc.phase = plan.current_task || null;
+    }
+  } catch { /* non-critical */ }
+
+  // --- dispatch_queue_snapshot ---
+  const queuePath = path.join(aiosDir, 'dispatch-queue.yaml');
+  try {
+    if (fs.existsSync(queuePath)) {
+      const queue = yaml.load(fs.readFileSync(queuePath, 'utf8'));
+      const dispatches = queue && Array.isArray(queue.dispatches) ? queue.dispatches : [];
+      const pending = dispatches.filter(d => d.status === 'pending').length;
+      const completed = dispatches.filter(d => d.status === 'completed').length;
+      const failed = dispatches.filter(d => d.status === 'failed').length;
+      doc.dispatch_queue_snapshot = { pending, completed, failed };
+    } else {
+      doc.dispatch_queue_snapshot = { pending: 0, completed: 0, failed: 0 };
+    }
+  } catch {
+    doc.dispatch_queue_snapshot = { pending: 0, completed: 0, failed: 0 };
+  }
+
+  // --- last_agent_outputs ---
+  try {
+    const entries = fs.readdirSync(aiosDir, { withFileTypes: true });
+    const outputFiles = entries
+      .filter(e => e.isFile() && e.name !== 'execution-plan.yaml' && e.name !== 'dispatch-queue.yaml' && e.name !== 'continue-here.yaml')
+      .map(e => {
+        const fullPath = path.join(aiosDir, e.name);
+        let mtime = 0;
+        try { mtime = fs.statSync(fullPath).mtimeMs; } catch { /* ignore */ }
+        return { name: e.name, mtime };
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, 3)
+      .map(e => e.name);
+    doc.last_agent_outputs = outputFiles;
+  } catch {
+    doc.last_agent_outputs = [];
+  }
+
+  // --- circuit_breaker_status ---
+  const cbPath = path.join(process.env.HOME, '.claude', '.hook-health', 'mcp-circuit-breaker-hook.json');
+  try {
+    if (fs.existsSync(cbPath)) {
+      const raw = JSON.parse(fs.readFileSync(cbPath, 'utf8'));
+      doc.circuit_breaker_status = raw;
+    } else {
+      doc.circuit_breaker_status = null;
+    }
+  } catch {
+    doc.circuit_breaker_status = null;
+  }
+
+  // --- pending_human_decisions (placeholder) ---
+  doc.pending_human_decisions = [];
+
+  // Write YAML
+  const targetDir = path.dirname(targetPath);
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.writeFileSync(targetPath, yaml.dump(doc, { lineWidth: 120 }), 'utf8');
+}
+
+async function main() {
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8');
+  } catch {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const ecosystemRoot = process.env.ECOSYSTEM_ROOT
+    || path.join(process.env.HOME, 'copywriting-ecosystem');
+
+  // Scan for active execution plan
+  const UUID_RE = /^[0-9a-f]{8}-/;
+  const SKIP_DIRS = new Set(['docs', 'scripts', 'site', 'export', 'knowledge', 'squads',
+    'squad-prompts', 'metodologias-de-copy', 'pesquisas-setup', 'copy-chief-tutorial', 'research']);
+
+  try {
+    const topDirs = fs.readdirSync(ecosystemRoot, { withFileTypes: true });
+    for (const topDir of topDirs) {
+      if (!topDir.isDirectory() || topDir.name.startsWith('.')) continue;
+      if (UUID_RE.test(topDir.name) || SKIP_DIRS.has(topDir.name)) continue;
+      const nichePath = path.join(ecosystemRoot, topDir.name);
+
+      let offerDirs;
+      try { offerDirs = fs.readdirSync(nichePath, { withFileTypes: true }); } catch { continue; }
+
+      for (const dir of offerDirs) {
+        if (!dir.isDirectory() || dir.name.startsWith('.')) continue;
+        const planPath = path.join(nichePath, dir.name, '.aios', 'execution-plan.yaml');
+        if (!fs.existsSync(planPath)) continue;
+
+        try {
+          const yaml = require('js-yaml');
+          const plan = yaml.load(fs.readFileSync(planPath, 'utf8'));
+          if (!plan || plan.status !== 'executing') continue;
+
+          const offerPath = `${topDir.name}/${dir.name}`;
+          const continuePath = path.join(nichePath, dir.name, '.aios', 'continue-here.yaml');
+          _writeContinueHereToPath(continuePath, offerPath);
+        } catch { /* non-critical */ }
+      }
+    }
+  } catch { /* fail-open */ }
+
+  process.stdout.write(JSON.stringify({}));
+}
+
+module.exports = { _writeContinueHereToPath };
+
+main().catch(() => process.exit(0));

package/framework/hooks/post-gate-auto-advance.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_path = require("path");
+var import_gate_auto_advance = require("../.aios-core/copy-chief/workflow/gate-auto-advance.js");
+const HOME = require("os").homedir();
+function main() {
+  try {
+    const stdin = (0, import_fs.readFileSync)(0, "utf8");
+    const input = JSON.parse(stdin);
+    if (!(0, import_gate_auto_advance.isGateTool)(input.tool_name)) {
+      process.exit(0);
+      return;
+    }
+    const r = (0, import_gate_auto_advance.handleGateAutoAdvance)(input);
+    if (r.blocked) console.error(`[AUTO-ADVANCE] Blocked \u2192 production: ${r.blocked}`);
+    else if (r.error) console.error(`[AUTO-ADVANCE] ${r.error}`);
+    else if (r.advanced) {
+      console.error(`[AUTO-ADVANCE] ${r.offerPath}: ${r.fromPhase} \u2192 ${r.toPhase}`);
+      const q = (0, import_path.join)(HOME, ".claude/kernel/queue.json");
+      if ((0, import_fs.existsSync)(q)) console.error(`[AUTO-ADVANCE] Kernel: bun run ~/.claude/kernel/main.ts --offer ${r.offerPath} --phase ${r.toPhase}`);
+    }
+  } catch (error) {
+    console.error(`[AUTO-ADVANCE] Error: ${error}`);
+  }
+  process.exit(0);
+}
+main();

package/framework/hooks/post-gate-auto-advance.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+/**
+ * post-gate-auto-advance.ts — PostToolUse Hook (thin wrapper)
+ *
+ * Fires after validate_gate or black_validation completes.
+ * If the gate PASSED and conditions are met, advances the offer phase.
+ *
+ * Business logic: ~/.claude/.aios-core/copy-chief/workflow/gate-auto-advance.ts
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import {
+  type PostToolUseInput,
+  isGateTool,
+  handleGateAutoAdvance,
+} from '../.aios-core/copy-chief/workflow/gate-auto-advance.ts';
+
+const HOME = require('os').homedir();
+
+function main(): void {
+  try {
+    const stdin = readFileSync(0, 'utf8');
+    const input: PostToolUseInput = JSON.parse(stdin);
+
+    if (!isGateTool(input.tool_name)) { process.exit(0); return; }
+
+    const r = handleGateAutoAdvance(input);
+
+    if (r.blocked)        console.error(`[AUTO-ADVANCE] Blocked → production: ${r.blocked}`);
+    else if (r.error)     console.error(`[AUTO-ADVANCE] ${r.error}`);
+    else if (r.advanced)  {
+      console.error(`[AUTO-ADVANCE] ${r.offerPath}: ${r.fromPhase} → ${r.toPhase}`);
+      const q = join(HOME, '.claude/kernel/queue.json');
+      if (existsSync(q))  console.error(`[AUTO-ADVANCE] Kernel: bun run ~/.claude/kernel/main.ts --offer ${r.offerPath} --phase ${r.toPhase}`);
+    }
+  } catch (error) {
+    console.error(`[AUTO-ADVANCE] Error: ${error}`);
+  }
+  process.exit(0);
+}
+
+main();

package/framework/hooks/post-mcp-mecanismo-update.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var fs = __toESM(require("fs"));
+var import_mecanismo_updater = require("../.aios-core/copy-chief/state/mecanismo-updater.js");
+function main() {
+  try {
+    const stdin = fs.readFileSync(0, "utf8");
+    const input = JSON.parse(stdin);
+    const result = (0, import_mecanismo_updater.postToolUse)(input);
+    if (result.message) {
+      console.log(result.message);
+    }
+    process.exit(0);
+  } catch {
+    process.exit(0);
+  }
+}
+main();

package/framework/hooks/post-mcp-mecanismo-update.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env bun
+/**
+ * Hook: post-mcp-mecanismo-update.ts (thin wrapper)
+ *
+ * Automatically updates mecanismo-unico.yaml state after MCP validation tools pass.
+ * Triggers: PostToolUse — consensus, blind_critic, emotional_stress_test
+ *
+ * Business logic: ~/.claude/.aios-core/copy-chief/state/mecanismo-updater.ts
+ */
+
+import * as fs from 'fs';
+import { postToolUse, type HookInput } from '../.aios-core/copy-chief/state/mecanismo-updater.ts';
+
+function main(): void {
+  try {
+    const stdin = fs.readFileSync(0, 'utf8');
+    const input: HookInput = JSON.parse(stdin);
+    const result = postToolUse(input);
+
+    if (result.message) {
+      console.log(result.message);
+    }
+    process.exit(0);
+  } catch {
+    // Parse errors or unexpected issues — exit cleanly
+    process.exit(0);
+  }
+}
+
+main();