@lucapimenta/copy-chief-black 1.0.0

package/framework/hooks/tool-enforcement-gate.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_session_state = require("../.aios-core/copy-chief/state/session-state");
+function main() {
+  try {
+    let stdin = "";
+    try {
+      stdin = (0, import_fs.readFileSync)(0, "utf8");
+    } catch {
+      allow();
+      return;
+    }
+    let input;
+    try {
+      input = JSON.parse(stdin || "{}");
+    } catch {
+      allow();
+      return;
+    }
+    if (input.stop_hook_active) {
+      allow();
+      return;
+    }
+    const state = (0, import_session_state.getSessionState)();
+    const gates = (0, import_session_state.getGatesStatus)();
+    const phase = (0, import_session_state.getCurrentPhase)();
+    if (phase === "production") {
+      const hasProductionWrites = (state.filesWritten || []).some((f) => /production\//i.test(f));
+      if (hasProductionWrites) {
+        if (!(0, import_session_state.hasPassedProductionValidation)()) {
+          blockMissingValidation();
+          return;
+        }
+        if (!(0, import_session_state.hasPassedFullValidation)()) {
+          console.error("[TOOL-GATE] \u26A0\uFE0F AVISO: Copy em production/ sem black_validation final");
+        }
+      }
+    }
+    allow();
+  } catch (error) {
+    try {
+      const logDir = `${process.env.HOME}/.claude/logs`;
+      const { mkdirSync: mkdir, appendFileSync } = require("fs");
+      try {
+        mkdir(logDir, { recursive: true });
+      } catch {
+      }
+      appendFileSync(
+        `${logDir}/hook-errors.log`,
+        `[${(/* @__PURE__ */ new Date()).toISOString()}] tool-enforcement-gate: ${error}
+`
+      );
+    } catch {
+    }
+    allow();
+  }
+}
+function allow() {
+  const output = {};
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+function blockMissingValidation() {
+  const state = (0, import_session_state.getSessionState)();
+  const validations = state.validationsPassed;
+  const missing = [];
+  if (!validations.blind_critic) {
+    missing.push("blind_critic");
+  }
+  if (!validations.emotional_stress_test) {
+    missing.push("emotional_stress_test");
+  }
+  const output = {
+    decision: "block",
+    reason: `\u{1F6AB} BLOQUEADO - VALIDA\xC7\xC3O MCP INCOMPLETA
+
+Copy em production/ detectada sem valida\xE7\xE3o obrigat\xF3ria.
+
+**Ferramentas faltando:** ${missing.join(", ")}
+
+**A\xC7\xC3O OBRIGAT\xD3RIA:**
+${missing.includes("blind_critic") ? `
+1. Executar blind_critic:
+\`\`\`
+mcp__copywriting__blind_critic(copy="[sua copy]", copy_type="hook|lead|vsl|lp|creative")
+\`\`\`
+` : ""}
+${missing.includes("emotional_stress_test") ? `
+2. Executar emotional_stress_test:
+\`\`\`
+mcp__copywriting__emotional_stress_test(copy="[sua copy]", copy_type="hook|lead|vsl|lp|creative")
+\`\`\`
+` : ""}
+
+**Por que isso existe (v7.0):**
+- blind_critic: Avalia\xE7\xE3o cega da copy (sem vi\xE9s de cria\xE7\xE3o)
+- emotional_stress_test: 4 testes de impacto visceral
+
+O sistema v7.0 usa estado determin\xEDstico, n\xE3o regex.
+Gates s\xE3o fonte de verdade para transi\xE7\xF5es de fase.
+
+**Ap\xF3s executar as valida\xE7\xF5es, a sess\xE3o pode continuar.**
+
+Ver: ~/.claude/reference/tool-usage-matrix.md`
+  };
+  console.error(`[TOOL-GATE] \u26A0\uFE0F Bloqueado: Valida\xE7\xF5es faltando: ${missing.join(", ")}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+main();

package/framework/hooks/tool-enforcement-gate.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+// ~/.claude/hooks/tool-enforcement-gate.ts
+// Hook Stop para verificação final de gates
+// v7.0 - Tool Enforcement System (2026-02-02)
+//
+// SIMPLIFICADO: Usa estado determinístico, NÃO regex
+// Verifica se gates passaram antes de permitir saída
+
+import { readFileSync, existsSync } from 'fs';
+import {
+  getSessionState,
+  getGatesStatus,
+  getCurrentPhase,
+  getActiveOffer,
+  hasPassedProductionValidation,
+  hasPassedFullValidation,
+} from '../.aios-core/copy-chief/state/session-state';
+
+interface StopInput {
+  session_id: string;
+  transcript_path: string;
+  stop_hook_active: boolean;
+  cwd: string;
+}
+
+interface StopOutput {
+  decision?: 'block';
+  reason?: string;
+}
+
+function main(): void {
+  try {
+    let stdin = '';
+    try {
+      stdin = readFileSync(0, 'utf8');
+    } catch {
+      allow();
+      return;
+    }
+
+    let input: StopInput;
+    try {
+      input = JSON.parse(stdin || '{}');
+    } catch {
+      allow();
+      return;
+    }
+
+    // Evita loop infinito
+    if (input.stop_hook_active) {
+      allow();
+      return;
+    }
+
+    const state = getSessionState();
+    const gates = getGatesStatus();
+    const phase = getCurrentPhase();
+
+    // Se está em production e tem arquivos escritos em production/, verificar validações
+    if (phase === 'production') {
+      const hasProductionWrites = (state.filesWritten || []).some(f => /production\//i.test(f));
+
+      if (hasProductionWrites) {
+        if (!hasPassedProductionValidation()) {
+          blockMissingValidation();
+          return;
+        }
+
+        if (!hasPassedFullValidation()) {
+          console.error('[TOOL-GATE] ⚠️ AVISO: Copy em production/ sem black_validation final');
+        }
+      }
+    }
+
+    allow();
+
+  } catch (error) {
+    // FAIL-OPEN: Any uncaught error = allow (never show error to user)
+    try {
+      const logDir = `${process.env.HOME}/.claude/logs`;
+      const { mkdirSync: mkdir, appendFileSync } = require('fs');
+      try { mkdir(logDir, { recursive: true }); } catch {}
+      appendFileSync(`${logDir}/hook-errors.log`,
+        `[${new Date().toISOString()}] tool-enforcement-gate: ${error}\n`);
+    } catch {}
+    allow();
+  }
+}
+
+function allow(): void {
+  const output: StopOutput = {};
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+function blockMissingValidation(): void {
+  const state = getSessionState();
+  const validations = state.validationsPassed;
+  const missing: string[] = [];
+
+  if (!validations.blind_critic) {
+    missing.push('blind_critic');
+  }
+  if (!validations.emotional_stress_test) {
+    missing.push('emotional_stress_test');
+  }
+
+  const output: StopOutput = {
+    decision: 'block',
+    reason: `🚫 BLOQUEADO - VALIDAÇÃO MCP INCOMPLETA
+
+Copy em production/ detectada sem validação obrigatória.
+
+**Ferramentas faltando:** ${missing.join(', ')}
+
+**AÇÃO OBRIGATÓRIA:**
+${missing.includes('blind_critic') ? `
+1. Executar blind_critic:
+\`\`\`
+mcp__copywriting__blind_critic(copy="[sua copy]", copy_type="hook|lead|vsl|lp|creative")
+\`\`\`
+` : ''}
+${missing.includes('emotional_stress_test') ? `
+2. Executar emotional_stress_test:
+\`\`\`
+mcp__copywriting__emotional_stress_test(copy="[sua copy]", copy_type="hook|lead|vsl|lp|creative")
+\`\`\`
+` : ''}
+
+**Por que isso existe (v7.0):**
+- blind_critic: Avaliação cega da copy (sem viés de criação)
+- emotional_stress_test: 4 testes de impacto visceral
+
+O sistema v7.0 usa estado determinístico, não regex.
+Gates são fonte de verdade para transições de fase.
+
+**Após executar as validações, a sessão pode continuar.**
+
+Ver: ~/.claude/reference/tool-usage-matrix.md`,
+  };
+
+  console.error(`[TOOL-GATE] ⚠️ Bloqueado: Validações faltando: ${missing.join(', ')}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+main();

package/framework/hooks/tool-matrix-enforcer.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_path = require("path");
+var import_config_loader = require("../.aios-core/copy-chief/config/config-loader");
+const ECOSYSTEM_ROOT = (0, import_path.join)(process.env.HOME, "copywriting-ecosystem");
+function getToolsFromOfferState(offerPath, gate) {
+  if (!offerPath) return [];
+  try {
+    const helixStatePath = (0, import_path.join)(ECOSYSTEM_ROOT, offerPath, "helix-state.yaml");
+    if (!(0, import_fs.existsSync)(helixStatePath)) return [];
+    const content = (0, import_fs.readFileSync)(helixStatePath, "utf-8");
+    const toolsByPhaseMatch = content.match(
+      new RegExp(`tools_by_phase:[\\s\\S]*?${gate}:\\s*\\n((?:\\s+-\\s+.+\\n)*)`, "m")
+    );
+    if (!toolsByPhaseMatch) return [];
+    const tools = [];
+    const toolRegex = /^\s+-\s+(.+)$/gm;
+    let match;
+    while ((match = toolRegex.exec(toolsByPhaseMatch[1])) !== null) {
+      const toolName = match[1].trim();
+      tools.push((0, import_config_loader.resolveToolName)(toolName));
+    }
+    return tools;
+  } catch {
+    return [];
+  }
+}
+function getToolsFromSessionState(gate) {
+  try {
+    const sessionPath = (0, import_path.join)(process.env.HOME, ".claude", "session-state", "current-session.json");
+    if (!(0, import_fs.existsSync)(sessionPath)) return [];
+    const content = (0, import_fs.readFileSync)(sessionPath, "utf-8");
+    const session = JSON.parse(content);
+    return session.toolsUsedByPhase?.[gate] || [];
+  } catch {
+    return [];
+  }
+}
+function detectOffer(input) {
+  const offerPath = input.offer_path;
+  if (offerPath) return offerPath;
+  try {
+    const sessionPath = (0, import_path.join)(process.env.HOME, ".claude", "session-state", "current-session.json");
+    if ((0, import_fs.existsSync)(sessionPath)) {
+      const content = (0, import_fs.readFileSync)(sessionPath, "utf-8");
+      const session = JSON.parse(content);
+      return session.activeOffer || null;
+    }
+  } catch {
+  }
+  return null;
+}
+function getMergedTools(offerPath, gate) {
+  const offerTools = getToolsFromOfferState(offerPath, gate);
+  const sessionTools = getToolsFromSessionState(gate);
+  return [.../* @__PURE__ */ new Set([...offerTools, ...sessionTools])];
+}
+function main() {
+  try {
+    const stdin = (0, import_fs.readFileSync)(0, "utf8");
+    const input = JSON.parse(stdin);
+    if (input.tool_name !== "mcp__copywriting__validate_gate") {
+      allow();
+      return;
+    }
+    const gateType = input.tool_input?.gate_type;
+    if (!gateType) {
+      allow();
+      return;
+    }
+    const validGates = ["research", "briefing", "production", "delivery"];
+    if (!validGates.includes(gateType)) {
+      allow();
+      return;
+    }
+    const offerPath = detectOffer(input.tool_input);
+    const requiredGroups = (0, import_config_loader.getRequiredToolGroups)(gateType);
+    const toolsUsed = getMergedTools(offerPath, gateType);
+    const missingGroups = [];
+    for (const group of requiredGroups) {
+      const hasAny = group.some((tool) => toolsUsed.includes(tool));
+      if (!hasAny) {
+        missingGroups.push(group);
+      }
+    }
+    if (missingGroups.length > 0) {
+      block(gateType, offerPath, toolsUsed, missingGroups);
+      return;
+    }
+    const recommended = (0, import_config_loader.getRecommendedTools)(gateType);
+    const missingRecommended = recommended.filter((t) => !toolsUsed.includes(t));
+    if (missingRecommended.length > 0) {
+      console.error(`[TOOL-MATRIX] Warning: Recommended tools not used: ${missingRecommended.map(import_config_loader.formatToolName).join(", ")}`);
+    }
+    console.error(`[TOOL-MATRIX] OK: All required tools used for ${gateType}`);
+    allow();
+  } catch (error) {
+    console.error(`[TOOL-MATRIX] Error: ${error}`);
+    allow();
+  }
+}
+function allow() {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+function block(gate, offer, toolsUsed, missingGroups) {
+  const missingMsg = missingGroups.map((group, i) => {
+    if (group.length === 1) {
+      return `  ${i + 1}. ${(0, import_config_loader.formatToolName)(group[0])}`;
+    }
+    return `  ${i + 1}. Uma das seguintes:
+${group.map((t) => `     - ${(0, import_config_loader.formatToolName)(t)}`).join("\n")}`;
+  }).join("\n");
+  const usedMsg = toolsUsed.length > 0 ? toolsUsed.map((t) => `  + ${(0, import_config_loader.formatToolName)(t)}`).join("\n") : "  (nenhuma)";
+  const output = {
+    decision: "block",
+    reason: `BLOQUEADO \u2014 Ferramentas obrigatorias nao usadas
+
+**validate_gate("${gate}")** requer:
+${missingMsg}
+
+**Ja usadas:**
+${usedMsg}
+
+**Oferta:** ${offer || "nao detectada"}
+**Fonte:** core-config.yaml quality.gates.${gate}
+
+Execute as ferramentas faltantes antes de chamar validate_gate.`
+  };
+  console.error(`[TOOL-MATRIX] BLOCKED: ${missingGroups.length} group(s) missing for ${gate}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+main();

package/framework/hooks/tool-matrix-enforcer.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env bun
+// ~/.claude/hooks/tool-matrix-enforcer.ts
+// Centralized Tool Matrix Enforcer — Gap Closure #2
+// v1.0 (2026-03-02)
+//
+// REPLACES: validate-gate-prereq.ts (which hardcoded required tools)
+// READS FROM: core-config.yaml quality.gates (single source of truth)
+// MATCHES: mcp__copywriting__validate_gate
+//
+// Checks required tools per gate phase from config, not hardcoded arrays.
+// Merges tool usage from offer-state (persistent) + session-state (volatile).
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import {
+  getRequiredToolGroups,
+  getRecommendedTools,
+  resolveToolName,
+  formatToolName,
+  loadOfferState,
+} from '../.aios-core/copy-chief/config/config-loader';
+
+const ECOSYSTEM_ROOT = join(process.env.HOME!, 'copywriting-ecosystem');
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface PreToolUseInput {
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+interface PreToolUseOutput {
+  decision?: 'block' | 'allow';
+  reason?: string;
+}
+
+type GateType = 'research' | 'briefing' | 'production' | 'delivery';
+
+// ─── Tool Usage Detection ────────────────────────────────────────────────────
+
+/**
+ * Get tools used in a phase from persistent offer state (helix-state.yaml).
+ */
+function getToolsFromOfferState(offerPath: string | null, gate: GateType): string[] {
+  if (!offerPath) return [];
+
+  try {
+    const helixStatePath = join(ECOSYSTEM_ROOT, offerPath, 'helix-state.yaml');
+    if (!existsSync(helixStatePath)) return [];
+
+    const content = readFileSync(helixStatePath, 'utf-8');
+
+    // Parse tools_by_phase section
+    const toolsByPhaseMatch = content.match(
+      new RegExp(`tools_by_phase:[\\s\\S]*?${gate}:\\s*\\n((?:\\s+-\\s+.+\\n)*)`, 'm')
+    );
+
+    if (!toolsByPhaseMatch) return [];
+
+    const tools: string[] = [];
+    const toolRegex = /^\s+-\s+(.+)$/gm;
+    let match;
+    while ((match = toolRegex.exec(toolsByPhaseMatch[1])) !== null) {
+      const toolName = match[1].trim();
+      tools.push(resolveToolName(toolName));
+    }
+    return tools;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get tools used from volatile session state.
+ */
+function getToolsFromSessionState(gate: GateType): string[] {
+  try {
+    const sessionPath = join(process.env.HOME!, '.claude', 'session-state', 'current-session.json');
+    if (!existsSync(sessionPath)) return [];
+
+    const content = readFileSync(sessionPath, 'utf-8');
+    const session = JSON.parse(content);
+
+    return session.toolsUsedByPhase?.[gate] || [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Detect active offer from gate input or session state.
+ */
+function detectOffer(input: Record<string, unknown>): string | null {
+  // From tool input
+  const offerPath = input.offer_path as string;
+  if (offerPath) return offerPath;
+
+  // From session state
+  try {
+    const sessionPath = join(process.env.HOME!, '.claude', 'session-state', 'current-session.json');
+    if (existsSync(sessionPath)) {
+      const content = readFileSync(sessionPath, 'utf-8');
+      const session = JSON.parse(content);
+      return session.activeOffer || null;
+    }
+  } catch {}
+
+  return null;
+}
+
+/**
+ * Merge tools from all sources (deduped).
+ */
+function getMergedTools(offerPath: string | null, gate: GateType): string[] {
+  const offerTools = getToolsFromOfferState(offerPath, gate);
+  const sessionTools = getToolsFromSessionState(gate);
+  return [...new Set([...offerTools, ...sessionTools])];
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+function main(): void {
+  try {
+    const stdin = readFileSync(0, 'utf8');
+    const input: PreToolUseInput = JSON.parse(stdin);
+
+    // Only process validate_gate
+    if (input.tool_name !== 'mcp__copywriting__validate_gate') {
+      allow();
+      return;
+    }
+
+    const gateType = input.tool_input?.gate_type as GateType;
+    if (!gateType) {
+      allow();
+      return;
+    }
+
+    const validGates: GateType[] = ['research', 'briefing', 'production', 'delivery'];
+    if (!validGates.includes(gateType)) {
+      allow();
+      return;
+    }
+
+    // Detect offer
+    const offerPath = detectOffer(input.tool_input);
+
+    // Get required tool groups from core-config.yaml
+    const requiredGroups = getRequiredToolGroups(gateType);
+
+    // Get tools actually used (merged: persistent + volatile)
+    const toolsUsed = getMergedTools(offerPath, gateType);
+
+    // Check each required group
+    const missingGroups: string[][] = [];
+    for (const group of requiredGroups) {
+      const hasAny = group.some(tool => toolsUsed.includes(tool));
+      if (!hasAny) {
+        missingGroups.push(group);
+      }
+    }
+
+    if (missingGroups.length > 0) {
+      block(gateType, offerPath, toolsUsed, missingGroups);
+      return;
+    }
+
+    // Check recommended tools (warning only)
+    const recommended = getRecommendedTools(gateType);
+    const missingRecommended = recommended.filter(t => !toolsUsed.includes(t));
+    if (missingRecommended.length > 0) {
+      console.error(`[TOOL-MATRIX] Warning: Recommended tools not used: ${missingRecommended.map(formatToolName).join(', ')}`);
+    }
+
+    console.error(`[TOOL-MATRIX] OK: All required tools used for ${gateType}`);
+    allow();
+
+  } catch (error) {
+    console.error(`[TOOL-MATRIX] Error: ${error}`);
+    allow(); // Fail-open
+  }
+}
+
+function allow(): void {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+
+function block(gate: GateType, offer: string | null, toolsUsed: string[], missingGroups: string[][]): void {
+  const missingMsg = missingGroups.map((group, i) => {
+    if (group.length === 1) {
+      return `  ${i + 1}. ${formatToolName(group[0])}`;
+    }
+    return `  ${i + 1}. Uma das seguintes:\n${group.map(t => `     - ${formatToolName(t)}`).join('\n')}`;
+  }).join('\n');
+
+  const usedMsg = toolsUsed.length > 0
+    ? toolsUsed.map(t => `  + ${formatToolName(t)}`).join('\n')
+    : '  (nenhuma)';
+
+  const output: PreToolUseOutput = {
+    decision: 'block',
+    reason: `BLOQUEADO — Ferramentas obrigatorias nao usadas
+
+**validate_gate("${gate}")** requer:
+${missingMsg}
+
+**Ja usadas:**
+${usedMsg}
+
+**Oferta:** ${offer || 'nao detectada'}
+**Fonte:** core-config.yaml quality.gates.${gate}
+
+Execute as ferramentas faltantes antes de chamar validate_gate.`,
+  };
+
+  console.error(`[TOOL-MATRIX] BLOCKED: ${missingGroups.length} group(s) missing for ${gate}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+main();

package/framework/hooks/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "./compiled",
+    "rootDir": ".",
+    "strict": false,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "declaration": false,
+    "sourceMap": false,
+    "removeComments": false,
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "baseUrl": "..",
+    "paths": {
+      "../.aios-core/*": ["../.aios-core/*"]
+    }
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "compiled", "*.d.ts"]
+}

package/framework/hooks/validate-before-commit.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+var import_commit_validator = require("../.aios-core/copy-chief/gates/commit-validator");
+async function main() {
+  const chunks = [];
+  const buf = Buffer.alloc(4096);
+  let rawInput = "";
+  try {
+    const fd = 0;
+    while (true) {
+      const bytesRead = require("fs").readSync(fd, buf, 0, buf.length, null);
+      if (bytesRead === 0) break;
+      chunks.push(buf.subarray(0, bytesRead));
+    }
+    rawInput = Buffer.concat(chunks).toString("utf-8").trim();
+  } catch {
+  }
+  if (!rawInput) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(rawInput);
+  } catch {
+    process.exit(0);
+    return;
+  }
+  try {
+    const decision = await (0, import_commit_validator.processHookEvent)(input);
+    if (!decision.allow) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "block",
+          reason: [
+            "COMMIT BLOCKED \u2014 Production files require passing validations:",
+            "",
+            ...decision.errors.map((e) => `  ${e}`),
+            ...decision.warnings.length > 0 ? ["", "Warnings:", ...decision.warnings.map((w) => `  ${w}`)] : [],
+            "",
+            "Fix the issues above before committing production/ files."
+          ].join("\n")
+        }
+      };
+      console.log(JSON.stringify(output));
+      process.exit(0);
+    }
+    if (decision.warnings.length > 0) {
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          reason: ["COMMIT ALLOWED with warnings:", ...decision.warnings.map((w) => `  ${w}`)].join("\n")
+        }
+      };
+      console.log(JSON.stringify(output));
+    }
+  } catch {
+  }
+  process.exit(0);
+}
+main();