@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/gates/gate-result-parser.ts

@@ -0,0 +1,106 @@
+// ~/.claude/.aios-core/copy-chief/gates/gate-result-parser.ts
+// Business logic extracted from gate-tracker.ts hook
+// v7.0 - Gate output parsing (JSON + text fallback)
+// Extracted: 2026-03-02
+
+import { GateType } from '../state/session-state';
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export type GateOutcome = 'PASSED' | 'BLOCKED' | 'UNKNOWN';
+
+export interface ValidateGateParseResult {
+  outcome: GateOutcome;
+  reasons?: string;
+}
+
+export interface BlackValidationParseResult {
+  score: number | null;
+  passed: boolean;
+}
+
+// ─── Score extraction regex patterns ─────────────────────────────────────────
+
+/** Matches "score: 8", "score 8.5", etc. (case-insensitive) */
+export const SCORE_REGEX = /score[:\s]+(\d+(?:\.\d+)?)/i;
+
+// ─── validate_gate output parser ─────────────────────────────────────────────
+
+/**
+ * Parses the tool_output of validate_gate.
+ * Strategy: JSON parse → field check → text pattern fallback.
+ */
+export function parseValidateGateOutput(output: unknown): ValidateGateParseResult {
+  const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+
+  // Attempt 1: JSON parse
+  try {
+    const result = typeof output === 'string' ? JSON.parse(output) : output;
+
+    if (result && typeof result === 'object') {
+      if ((result as Record<string, unknown>).result === 'PASSED') {
+        return { outcome: 'PASSED' };
+      }
+      if ((result as Record<string, unknown>).result === 'BLOCKED') {
+        const reasons = ((result as Record<string, unknown>).reasons as string[] | undefined)?.join(', ') || 'sem razões';
+        return { outcome: 'BLOCKED', reasons };
+      }
+    }
+  } catch {
+    // Fall through to text detection
+  }
+
+  // Attempt 2: Text pattern detection
+  if (/PASSED/i.test(outputStr)) {
+    return { outcome: 'PASSED' };
+  }
+  if (/BLOCKED/i.test(outputStr)) {
+    return { outcome: 'BLOCKED' };
+  }
+
+  return { outcome: 'UNKNOWN' };
+}
+
+// ─── black_validation output parser ──────────────────────────────────────────
+
+/**
+ * Parses the tool_output of black_validation.
+ * Strategy: JSON parse → field check → regex fallback on raw string.
+ * Returns null score if nothing can be extracted.
+ */
+export function parseBlackValidationOutput(output: unknown): BlackValidationParseResult {
+  const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
+
+  // Attempt 1: JSON parse with known score fields
+  try {
+    const result = typeof output === 'string' ? JSON.parse(output) : output;
+
+    if (result && typeof result === 'object') {
+      const r = result as Record<string, unknown>;
+      let score: number | null = null;
+
+      if (typeof r.score === 'number') {
+        score = r.score;
+      } else if (typeof r.total_score === 'number') {
+        score = r.total_score;
+      } else if (typeof r.weighted_score === 'number') {
+        score = r.weighted_score;
+      }
+
+      if (score !== null) {
+        return { score, passed: score >= 8 };
+      }
+    }
+  } catch {
+    // Fall through to regex extraction
+  }
+
+  // Attempt 2: Regex on raw output string
+  const scoreMatch = outputStr.match(SCORE_REGEX);
+  if (scoreMatch) {
+    const score = parseFloat(scoreMatch[1]);
+    return { score, passed: score >= 8 };
+  }
+
+  return { score: null, passed: false };
+}

package/framework/.aios-core/copy-chief/gates/gate-trend-analyzer.js

@@ -0,0 +1,122 @@
+'use strict';
+
+/**
+ * Gate Score Trend Analyzer (U-16)
+ *
+ * Analyzes gate audit trail entries to detect:
+ * - Score regression (>10% drop over last 3 evaluations)
+ * - Persistent low criteria (same criteria below threshold 3+ times)
+ * - Improvement velocity (positive trend direction)
+ *
+ * @module gate-trend-analyzer
+ * @version 1.0.0
+ * @atom U-16
+ */
+
+const { readAuditTrail } = require('./gate-audit');
+
+const REGRESSION_THRESHOLD_PERCENT = 10;
+const PERSISTENT_LOW_COUNT = 3;
+const MIN_ENTRIES_FOR_TREND = 3;
+
+/**
+ * Analyze trends from an audit trail array.
+ *
+ * @param {object[]} trail - Array of audit entries with { total_weighted, timestamp, criteria }
+ * @returns {{ regression: boolean, direction: string, drop_percent: number, persistent_low: string[], velocity: number, entries_analyzed: number }}
+ */
+function analyzeTrends(trail) {
+  const result = {
+    regression: false,
+    direction: 'stable',
+    drop_percent: 0,
+    persistent_low: [],
+    velocity: 0,
+    entries_analyzed: trail.length,
+  };
+
+  if (!trail || trail.length < MIN_ENTRIES_FOR_TREND) {
+    return result;
+  }
+
+  // Sort by timestamp (oldest first)
+  const sorted = [...trail].sort((a, b) =>
+    new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+
+  const scores = sorted.map(e => e.total_weighted).filter(s => typeof s === 'number');
+  if (scores.length < MIN_ENTRIES_FOR_TREND) return result;
+
+  // Direction: compare first half average vs second half average
+  const mid = Math.floor(scores.length / 2);
+  const firstHalf = scores.slice(0, mid);
+  const secondHalf = scores.slice(mid);
+  const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
+  const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / secondHalf.length;
+
+  if (secondAvg > firstAvg + 2) {
+    result.direction = 'improving';
+  } else if (secondAvg < firstAvg - 2) {
+    result.direction = 'declining';
+  }
+
+  // Regression: check last 3 entries for >10% drop
+  const recent = scores.slice(-3);
+  if (recent.length >= 3) {
+    const peak = Math.max(recent[0], recent[1]);
+    const last = recent[recent.length - 1];
+    if (peak > 0) {
+      const drop = ((peak - last) / peak) * 100;
+      result.drop_percent = Math.round(drop * 10) / 10;
+      if (drop > REGRESSION_THRESHOLD_PERCENT) {
+        result.regression = true;
+      }
+    }
+  }
+
+  // Velocity: score change per evaluation (last 3)
+  if (scores.length >= 2) {
+    const last3 = scores.slice(-3);
+    const changes = [];
+    for (let i = 1; i < last3.length; i++) {
+      changes.push(last3[i] - last3[i - 1]);
+    }
+    result.velocity = Math.round((changes.reduce((a, b) => a + b, 0) / changes.length) * 10) / 10;
+  }
+
+  // Persistent low criteria
+  const criteriaFailCounts = {};
+  const recentEntries = sorted.slice(-PERSISTENT_LOW_COUNT);
+  for (const entry of recentEntries) {
+    if (!Array.isArray(entry.criteria)) continue;
+    for (const c of entry.criteria) {
+      const name = c.name || c.id;
+      if (!name) continue;
+      const score = c.score || c.weighted_score || 0;
+      if (score < 6) {
+        criteriaFailCounts[name] = (criteriaFailCounts[name] || 0) + 1;
+      }
+    }
+  }
+  for (const [name, count] of Object.entries(criteriaFailCounts)) {
+    if (count >= PERSISTENT_LOW_COUNT) {
+      result.persistent_low.push(name);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Analyze trends for a specific gate on an offer.
+ *
+ * @param {string} offerPath - Offer path (relative or absolute)
+ * @param {string} gateName - Gate name (e.g., 'briefing', 'research', 'production')
+ * @returns {object} Trend analysis result
+ */
+function analyzeGateTrends(offerPath, gateName) {
+  const trail = readAuditTrail(offerPath, gateName);
+  return analyzeTrends(trail);
+}
+
+module.exports = { analyzeTrends, analyzeGateTrends, REGRESSION_THRESHOLD_PERCENT, MIN_ENTRIES_FOR_TREND };

package/framework/.aios-core/copy-chief/gates/mecanismo-gate.js

@@ -0,0 +1,184 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mecanismo_gate_exports = {};
+__export(mecanismo_gate_exports, {
+  BLIND_CRITIC_THRESHOLD: () => BLIND_CRITIC_THRESHOLD,
+  EMOTIONAL_STRESS_THRESHOLD: () => EMOTIONAL_STRESS_THRESHOLD,
+  buildInvalidMecanismoMessage: () => buildInvalidMecanismoMessage,
+  buildMissingMecanismoMessage: () => buildMissingMecanismoMessage,
+  findOfferRoot: () => findOfferRoot,
+  isMecanismoValidated: () => isMecanismoValidated,
+  loadMecanismo: () => loadMecanismo,
+  preToolUse: () => preToolUse
+});
+module.exports = __toCommonJS(mecanismo_gate_exports);
+var import_fs = require("fs");
+var path = __toESM(require("path"));
+var import_yaml = require("yaml");
+const BLIND_CRITIC_THRESHOLD = 8;
+const EMOTIONAL_STRESS_THRESHOLD = 8;
+function findOfferRoot(filePath) {
+  let current = path.dirname(filePath);
+  const maxDepth = 10;
+  let depth = 0;
+  while (depth < maxDepth) {
+    if ((0, import_fs.existsSync)(path.join(current, "CONTEXT.md")) || (0, import_fs.existsSync)(path.join(current, "mecanismo-unico.yaml"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+    depth++;
+  }
+  return null;
+}
+function loadMecanismo(offerPath) {
+  const mecanismoPath = path.join(offerPath, "mecanismo-unico.yaml");
+  if (!(0, import_fs.existsSync)(mecanismoPath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(mecanismoPath, "utf-8");
+    return (0, import_yaml.parse)(content);
+  } catch (e) {
+    console.error(`Error parsing mecanismo-unico.yaml: ${e}`);
+    return null;
+  }
+}
+function isMecanismoValidated(data) {
+  const validation = data.unique_mechanism?.validation || data.validation || data;
+  const state = data.unique_mechanism?.validation?.state || data.state || validation?.state || "UNDEFINED";
+  if (state === "APPROVED" || state === "VALIDATED") {
+    return { valid: true, reason: `State: ${state}` };
+  }
+  const mcp = validation?.mcp_validation || data.unique_mechanism?.validation?.mcp_validation;
+  if (!mcp) {
+    return {
+      valid: false,
+      reason: "MCP validation not run. Execute: consensus, blind_critic, emotional_stress_test"
+    };
+  }
+  const issues = [];
+  if (!mcp.consensus_passed) {
+    issues.push("consensus not passed");
+  }
+  if ((mcp.blind_critic_mup_score || 0) < BLIND_CRITIC_THRESHOLD) {
+    issues.push(`blind_critic MUP: ${mcp.blind_critic_mup_score || 0}/10 (need ${BLIND_CRITIC_THRESHOLD}+)`);
+  }
+  if ((mcp.blind_critic_mus_score || 0) < BLIND_CRITIC_THRESHOLD) {
+    issues.push(`blind_critic MUS: ${mcp.blind_critic_mus_score || 0}/10 (need ${BLIND_CRITIC_THRESHOLD}+)`);
+  }
+  if ((mcp.emotional_stress_test_score || 0) < EMOTIONAL_STRESS_THRESHOLD) {
+    issues.push(`emotional_stress_test: ${mcp.emotional_stress_test_score || 0}/10 (need ${EMOTIONAL_STRESS_THRESHOLD}+)`);
+  }
+  if (issues.length > 0) {
+    return { valid: false, reason: `MCP validation issues: ${issues.join(", ")}` };
+  }
+  return { valid: false, reason: `State is ${state}, needs VALIDATED or APPROVED` };
+}
+function buildMissingMecanismoMessage(offerRoot) {
+  return `
+\u{1F6AB} BLOQUEADO - MECANISMO UNICO NAO DEFINIDO
+
+Para escrever em production/, o Mecanismo Unico deve estar validado.
+
+Arquivo faltando: ${path.join(offerRoot, "mecanismo-unico.yaml")}
+
+ACAO OBRIGATORIA:
+1. Crie mecanismo-unico.yaml usando o template
+2. Preencha MUP, MUS e INDUTOR
+3. Valide via MCP (consensus, blind_critic, emotional_stress_test)
+4. Marque human_approved: true
+
+Template: ~/.claude/templates/mecanismo-unico-template.md
+Schema: ~/.claude/schemas/mecanismo-unico.schema.yaml
+`;
+}
+function buildInvalidMecanismoMessage(reason, offerRoot) {
+  return `
+\u{1F6AB} BLOQUEADO - MECANISMO NAO VALIDADO
+
+${reason}
+
+Para escrever em production/, o Mecanismo Unico deve estar VALIDATED ou APPROVED.
+
+ACAO OBRIGATORIA:
+1. Complete mecanismo-unico.yaml
+2. Run: consensus (selecionar MUP/MUS)
+3. Run: blind_critic (score >= 8 para MUP e MUS)
+4. Run: emotional_stress_test (score >= 8)
+5. Set human_approved: true
+
+Validar: python3 ~/copywriting-ecosystem/scripts/validate-mecanismo.py ${offerRoot}
+`;
+}
+function preToolUse(input) {
+  const { tool_name, tool_input } = input;
+  if (tool_name === "Write" && tool_input.file_path) {
+    const filePath = tool_input.file_path;
+    if (!filePath.includes("/production/")) {
+      return { decision: "allow" };
+    }
+    const offerRoot = findOfferRoot(filePath);
+    if (!offerRoot) {
+      console.warn("Could not determine offer root for production write");
+      return { decision: "allow" };
+    }
+    const mecanismo = loadMecanismo(offerRoot);
+    if (!mecanismo) {
+      return {
+        decision: "block",
+        message: buildMissingMecanismoMessage(offerRoot)
+      };
+    }
+    const { valid, reason } = isMecanismoValidated(mecanismo);
+    if (!valid) {
+      return {
+        decision: "block",
+        message: buildInvalidMecanismoMessage(reason, offerRoot)
+      };
+    }
+    return { decision: "allow" };
+  }
+  if (tool_name === "mcp__copywriting__validate_gate" && tool_input.gate_name === "briefing") {
+    console.log("validate_gate(briefing) called - ensure mecanismo-unico.yaml is validated");
+    return { decision: "allow" };
+  }
+  return { decision: "allow" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLIND_CRITIC_THRESHOLD,
+  EMOTIONAL_STRESS_THRESHOLD,
+  buildInvalidMecanismoMessage,
+  buildMissingMecanismoMessage,
+  findOfferRoot,
+  isMecanismoValidated,
+  loadMecanismo,
+  preToolUse
+});

package/framework/.aios-core/copy-chief/gates/mecanismo-gate.ts

@@ -0,0 +1,259 @@
+/**
+ * mecanismo-gate.ts — Mecanismo Unico Gate Module
+ * Part of AIOS Copy Chief OS Layer
+ *
+ * Enforces Mecanismo Unico validation before allowing production writes.
+ * Blocks production/ writes if mecanismo-unico.yaml is missing or not validated.
+ *
+ * Usage:
+ *   import { preToolUse } from './mecanismo-gate'
+ *
+ * Exit conventions (for CLI wrappers):
+ *   - Allow → exit 0
+ *   - Block → print message to stdout, then process.exit(2)
+ *
+ * Extracted from: ~/.claude/hooks/mecanismo-validation.ts
+ * Created: 2026-02 | Refactored: 2026-03-02
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import * as path from 'path';
+import { parse as yamlParse } from 'yaml';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+export const BLIND_CRITIC_THRESHOLD = 8;
+export const EMOTIONAL_STRESS_THRESHOLD = 8;
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export interface MecanismoData {
+  unique_mechanism?: {
+    validation?: {
+      state?: string;
+      mcp_validation?: {
+        consensus_passed?: boolean;
+        blind_critic_mup_score?: number;
+        blind_critic_mus_score?: number;
+        emotional_stress_test_score?: number;
+        all_passed?: boolean;
+      };
+      human_approved?: boolean;
+    };
+  };
+  // Flat format support
+  state?: string;
+  validation?: Record<string, unknown>;
+}
+
+export interface HookInput {
+  tool_name: string;
+  tool_input: {
+    file_path?: string;
+    gate_name?: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface HookOutput {
+  decision: 'allow' | 'block' | 'modify';
+  message?: string;
+  modified_input?: Record<string, unknown>;
+}
+
+// ─── Offer Root Discovery ─────────────────────────────────────────────────────
+
+/**
+ * Walk up the directory tree from a file path to find the offer root.
+ * Identified by the presence of CONTEXT.md or mecanismo-unico.yaml.
+ */
+export function findOfferRoot(filePath: string): string | null {
+  let current = path.dirname(filePath);
+  const maxDepth = 10;
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    if (
+      existsSync(path.join(current, 'CONTEXT.md')) ||
+      existsSync(path.join(current, 'mecanismo-unico.yaml'))
+    ) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+    depth++;
+  }
+
+  return null;
+}
+
+// ─── Mecanismo Loader ─────────────────────────────────────────────────────────
+
+/**
+ * Load and parse the mecanismo-unico.yaml for an offer root path.
+ * Returns null if the file doesn't exist or fails to parse.
+ */
+export function loadMecanismo(offerPath: string): MecanismoData | null {
+  const mecanismoPath = path.join(offerPath, 'mecanismo-unico.yaml');
+
+  if (!existsSync(mecanismoPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(mecanismoPath, 'utf-8');
+    return yamlParse(content) as MecanismoData;
+  } catch (e) {
+    console.error(`Error parsing mecanismo-unico.yaml: ${e}`);
+    return null;
+  }
+}
+
+// ─── Validation Logic ─────────────────────────────────────────────────────────
+
+/**
+ * Check if a parsed MecanismoData is in a validated/approved state.
+ * Supports both nested (unique_mechanism.validation.state) and flat (state) formats.
+ */
+export function isMecanismoValidated(data: MecanismoData): { valid: boolean; reason: string } {
+  const validation = data.unique_mechanism?.validation || (data.validation as any) || data;
+  const state =
+    data.unique_mechanism?.validation?.state ||
+    data.state ||
+    (validation as any)?.state ||
+    'UNDEFINED';
+
+  if (state === 'APPROVED' || state === 'VALIDATED') {
+    return { valid: true, reason: `State: ${state}` };
+  }
+
+  const mcp =
+    (validation as any)?.mcp_validation ||
+    data.unique_mechanism?.validation?.mcp_validation;
+
+  if (!mcp) {
+    return {
+      valid: false,
+      reason: 'MCP validation not run. Execute: consensus, blind_critic, emotional_stress_test',
+    };
+  }
+
+  const issues: string[] = [];
+
+  if (!mcp.consensus_passed) {
+    issues.push('consensus not passed');
+  }
+  if ((mcp.blind_critic_mup_score || 0) < BLIND_CRITIC_THRESHOLD) {
+    issues.push(`blind_critic MUP: ${mcp.blind_critic_mup_score || 0}/10 (need ${BLIND_CRITIC_THRESHOLD}+)`);
+  }
+  if ((mcp.blind_critic_mus_score || 0) < BLIND_CRITIC_THRESHOLD) {
+    issues.push(`blind_critic MUS: ${mcp.blind_critic_mus_score || 0}/10 (need ${BLIND_CRITIC_THRESHOLD}+)`);
+  }
+  if ((mcp.emotional_stress_test_score || 0) < EMOTIONAL_STRESS_THRESHOLD) {
+    issues.push(`emotional_stress_test: ${mcp.emotional_stress_test_score || 0}/10 (need ${EMOTIONAL_STRESS_THRESHOLD}+)`);
+  }
+
+  if (issues.length > 0) {
+    return { valid: false, reason: `MCP validation issues: ${issues.join(', ')}` };
+  }
+
+  return { valid: false, reason: `State is ${state}, needs VALIDATED or APPROVED` };
+}
+
+// ─── Block Message Builders ───────────────────────────────────────────────────
+
+export function buildMissingMecanismoMessage(offerRoot: string): string {
+  return `
+\uD83D\uDEAB BLOQUEADO - MECANISMO UNICO NAO DEFINIDO
+
+Para escrever em production/, o Mecanismo Unico deve estar validado.
+
+Arquivo faltando: ${path.join(offerRoot, 'mecanismo-unico.yaml')}
+
+ACAO OBRIGATORIA:
+1. Crie mecanismo-unico.yaml usando o template
+2. Preencha MUP, MUS e INDUTOR
+3. Valide via MCP (consensus, blind_critic, emotional_stress_test)
+4. Marque human_approved: true
+
+Template: ~/.claude/templates/mecanismo-unico-template.md
+Schema: ~/.claude/schemas/mecanismo-unico.schema.yaml
+`;
+}
+
+export function buildInvalidMecanismoMessage(reason: string, offerRoot: string): string {
+  return `
+\uD83D\uDEAB BLOQUEADO - MECANISMO NAO VALIDADO
+
+${reason}
+
+Para escrever em production/, o Mecanismo Unico deve estar VALIDATED ou APPROVED.
+
+ACAO OBRIGATORIA:
+1. Complete mecanismo-unico.yaml
+2. Run: consensus (selecionar MUP/MUS)
+3. Run: blind_critic (score >= 8 para MUP e MUS)
+4. Run: emotional_stress_test (score >= 8)
+5. Set human_approved: true
+
+Validar: python3 ~/copywriting-ecosystem/scripts/validate-mecanismo.py ${offerRoot}
+`;
+}
+
+// ─── Main Gate Handler ────────────────────────────────────────────────────────
+
+/**
+ * PreToolUse gate handler.
+ *
+ * Checks:
+ * 1. Write to production/ → requires validated mecanismo-unico.yaml
+ * 2. validate_gate("briefing") → warns (actual enforcement in MCP tool)
+ */
+export function preToolUse(input: HookInput): HookOutput {
+  const { tool_name, tool_input } = input;
+
+  // Check 1: Write to production/ directory
+  if (tool_name === 'Write' && tool_input.file_path) {
+    const filePath = tool_input.file_path;
+
+    if (!filePath.includes('/production/')) {
+      return { decision: 'allow' };
+    }
+
+    const offerRoot = findOfferRoot(filePath);
+    if (!offerRoot) {
+      console.warn('Could not determine offer root for production write');
+      return { decision: 'allow' };
+    }
+
+    const mecanismo = loadMecanismo(offerRoot);
+
+    if (!mecanismo) {
+      return {
+        decision: 'block',
+        message: buildMissingMecanismoMessage(offerRoot),
+      };
+    }
+
+    const { valid, reason } = isMecanismoValidated(mecanismo);
+
+    if (!valid) {
+      return {
+        decision: 'block',
+        message: buildInvalidMecanismoMessage(reason, offerRoot),
+      };
+    }
+
+    return { decision: 'allow' };
+  }
+
+  // Check 2: validate_gate("briefing") call — warn only
+  if (tool_name === 'mcp__copywriting__validate_gate' && tool_input.gate_name === 'briefing') {
+    console.log('validate_gate(briefing) called - ensure mecanismo-unico.yaml is validated');
+    return { decision: 'allow' };
+  }
+
+  return { decision: 'allow' };
+}