@lucapimenta/copy-chief-black 1.0.0

package/framework/hooks/subagent-stop-validate.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Hook: SubagentStop
+# Purpose: Log subagent completion and optionally validate output
+# v5.3 - FASE 4 Hook Avançado
+
+set -e
+
+# Read input JSON from stdin
+read -r input_json
+
+agent_id=$(echo "$input_json" | jq -r '.agent_id // "unknown"')
+agent_type=$(echo "$input_json" | jq -r '.agent_type // "unknown"')
+
+# Log to file
+LOG_FILE="$HOME/.claude/logs/subagents.log"
+mkdir -p "$(dirname "$LOG_FILE")"
+
+echo "[$(date '+%Y-%m-%d %H:%M:%S')] STOP  | Agent: $agent_type | ID: $agent_id" >> "$LOG_FILE"
+
+# For research agents, could add validation here
+# if [[ "$agent_type" == "researcher" ]]; then
+#   # Check if required outputs exist
+# fi
+
+# Always allow completion
+exit 0

package/framework/hooks/suggestion-on-gate.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+var import_suggestion_engine = require("../.aios-core/copy-chief/utils/suggestion-engine");
+function main() {
+  const raw = process.env.CLAUDE_TOOL_USE_CONTEXT;
+  if (!raw) return;
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const gateTools = [
+    "mcp__copywriting__validate_gate",
+    "mcp__copywriting__black_validation"
+  ];
+  if (!gateTools.includes(input.tool_name)) return;
+  const engine = new import_suggestion_engine.SuggestionEngine();
+  const offerPath = input.tool_input?.offer_path || input.tool_input?.offerPath || "";
+  const context = engine.buildContext({ offerPath });
+  const output = input.tool_output || "";
+  if (/pass|approved|score.*[89]/i.test(output)) {
+    context.executionSignals = { gate_status: "passed" };
+  } else if (/fail|blocked|score.*[0-6]/i.test(output)) {
+    context.executionSignals = { gate_status: "failed" };
+  }
+  context.lastCommand = input.tool_name.replace("mcp__copywriting__", "");
+  context.lastCommands = [context.lastCommand];
+  const result = engine.suggestNext(context);
+  if (result.suggestions.length > 0) {
+    const top = result.suggestions[0];
+    const msg = `\u{1F4A1} Next: ${top.command}${top.args ? " " + top.args : ""} \u2014 ${top.description} (${Math.round(top.confidence * 100)}% confidence)`;
+    console.log(JSON.stringify({ result: msg }));
+  }
+}
+main();

package/framework/hooks/suggestion-on-gate.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+// hooks/suggestion-on-gate.ts — PostToolUse hook
+// Fires after validate_gate / black_validation to suggest next action
+// via SuggestionEngine.
+//
+// Wires: hooks/lib/aios/suggestion-engine.ts → PostToolUse hook
+
+import { SuggestionEngine, type SuggestionContext } from '../.aios-core/copy-chief/utils/suggestion-engine';
+
+interface HookInput {
+  tool_name: string;
+  tool_input: Record<string, any>;
+  tool_output?: string;
+}
+
+function main(): void {
+  const raw = process.env.CLAUDE_TOOL_USE_CONTEXT;
+  if (!raw) return;
+
+  let input: HookInput;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  // Only fire after gate tools
+  const gateTools = [
+    'mcp__copywriting__validate_gate',
+    'mcp__copywriting__black_validation',
+  ];
+  if (!gateTools.includes(input.tool_name)) return;
+
+  const engine = new SuggestionEngine();
+
+  // Build context from tool input
+  const offerPath = input.tool_input?.offer_path || input.tool_input?.offerPath || '';
+  const context: SuggestionContext = engine.buildContext({ offerPath });
+
+  // Detect execution state from gate output
+  const output = input.tool_output || '';
+  if (/pass|approved|score.*[89]/i.test(output)) {
+    context.executionSignals = { gate_status: 'passed' };
+  } else if (/fail|blocked|score.*[0-6]/i.test(output)) {
+    context.executionSignals = { gate_status: 'failed' };
+  }
+
+  context.lastCommand = input.tool_name.replace('mcp__copywriting__', '');
+  context.lastCommands = [context.lastCommand];
+
+  const result = engine.suggestNext(context);
+
+  if (result.suggestions.length > 0) {
+    const top = result.suggestions[0];
+    const msg = `💡 Next: ${top.command}${top.args ? ' ' + top.args : ''} — ${top.description} (${Math.round(top.confidence * 100)}% confidence)`;
+    // Output as system message for the user
+    console.log(JSON.stringify({ result: msg }));
+  }
+}
+
+main();

package/framework/hooks/synapse-engine.cjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// SYN-14: Boot time captured before ANY require — measures hook cold start
+const _BOOT_TIME = process.hrtime.bigint();
+'use strict';
+
+/**
+ * SYNAPSE Hook Entry Point — UserPromptSubmit
+ *
+ * Thin wrapper that reads JSON from stdin, delegates to SynapseEngine,
+ * and writes <synapse-rules> context to stdout.
+ *
+ * - Silent exit on missing .synapse/ directory
+ * - Silent exit on any error (never blocks the user prompt)
+ * - All errors logged to stderr with [synapse-hook] prefix
+ * - 5s safety timeout as defense-in-depth
+ *
+ * @module synapse-engine-hook
+ */
+
+const path = require('path');
+// Copy Chief BLACK: .aios-core lives at ~/.claude/.aios-core/ (one level up from hooks/)
+const { resolveHookRuntime, buildHookOutput } = require(
+  path.join(__dirname, '..', '.aios-core', 'core', 'synapse', 'runtime', 'hook-runtime.js'),
+);
+
+/** Safety timeout (ms) — defense-in-depth; Claude Code also manages hook timeout. */
+const HOOK_TIMEOUT_MS = 5000;
+
+/**
+ * Read all data from stdin as a JSON object.
+ * @returns {Promise<object>} Parsed JSON input
+ */
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('error', (e) => reject(e));
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try { resolve(JSON.parse(data)); }
+      catch (e) { reject(e); }
+    });
+  });
+}
+
+/** Main hook execution pipeline. */
+async function main() {
+  const input = await readStdin();
+  const runtime = resolveHookRuntime(input);
+  if (!runtime) return;
+
+  const result = await runtime.engine.process(input.prompt, runtime.session);
+  process.stdout.write(JSON.stringify(buildHookOutput(result.xml)));
+}
+
+/**
+ * Safely exit the process — no-op inside Jest workers to prevent worker crashes.
+ * @param {number} code - Exit code
+ */
+function safeExit(code) {
+  if (process.env.JEST_WORKER_ID) return;
+  process.exit(code);
+}
+
+/** Entry point runner — sets safety timeout and executes main(). */
+function run() {
+  const timer = setTimeout(() => safeExit(0), HOOK_TIMEOUT_MS);
+  timer.unref();
+  main().catch((err) => {
+    console.error(`[synapse-hook] ${err.message}`);
+    safeExit(0);
+  });
+}
+
+if (require.main === module) run();
+
+module.exports = { readStdin, main, run, HOOK_TIMEOUT_MS };

package/framework/hooks/sync-repos-on-stop.cjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// sync-repos-on-stop.cjs - Auto-sync repos when session ends
+// Hook: Stop
+// Sincroniza 5 repos: 2 source + 3 distribution
+
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const HOME = os.homedir();
+const CLAUDE_HOME = path.join(HOME, '.claude');
+const ECO_ROOT = path.join(HOME, 'copywriting-ecosystem');
+const PACKAGES = path.join(ECO_ROOT, 'packages');
+const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+const LOG_FILE = path.join(os.tmpdir(), `claude-sync-${dateStr}.log`);
+
+function log(msg) {
+  const ts = new Date().toISOString().slice(11, 19);
+  fs.appendFileSync(LOG_FILE, `[${ts}] ${msg}\n`);
+}
+
+// ── rsync-like copy (only changed files) ──────────────────────────
+function syncDir(src, dest) {
+  if (!fs.existsSync(src)) return 0;
+  if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+  let count = 0;
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    // skip git, node_modules, runtime data
+    if (['.git', 'node_modules', '.DS_Store', 'session-state', 'session-env',
+         'session-digests', 'agent-memory', 'logs', 'debug', 'cache',
+         'paste-cache', 'shell-snapshots', 'production-logs', 'production-loops',
+         'file-history', 'memory', 'artifacts', 'projects', 'plans',
+         'telemetry', 'todos', 'tasks', 'history.jsonl', 'mcp-needs-auth-cache.json',
+         'stats-cache.json', 'archive'].includes(entry.name)) continue;
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      count += syncDir(srcPath, destPath);
+    } else {
+      // Only copy if source is newer or dest doesn't exist
+      if (!fs.existsSync(destPath)) {
+        fs.copyFileSync(srcPath, destPath);
+        count++;
+      } else {
+        const srcStat = fs.statSync(srcPath);
+        const destStat = fs.statSync(destPath);
+        if (srcStat.mtimeMs > destStat.mtimeMs) {
+          fs.copyFileSync(srcPath, destPath);
+          count++;
+        }
+      }
+    }
+  }
+  return count;
+}
+
+// ── Distribution sync: source → package repo ──────────────────────
+function syncDistribution() {
+  log('--- Distribution sync ---');
+
+  // 1. copy-chief-black: ~/.claude/ → packages/copy-chief-black/framework/
+  const coreFramework = path.join(PACKAGES, 'copy-chief-black', 'framework');
+  const coreDirs = [
+    '.aios-core', 'hooks', 'scripts', 'agents', 'copy-squad',
+    'plugins', 'schemas', 'skills', 'commands',
+    'knowledge', 'reference', 'references', 'dossiers', 'experts',
+    'config', 'checklists', 'rules', 'data',
+    'templates', 'workflows',
+    'stories', 'gotchas', 'learned-patterns', 'ids',
+    'docs', 'tests'
+  ];
+  let coreCount = 0;
+  for (const dir of coreDirs) {
+    const src = path.join(CLAUDE_HOME, dir);
+    if (fs.existsSync(src)) {
+      coreCount += syncDir(src, path.join(coreFramework, dir));
+    }
+  }
+  // Root config files
+  const rootFiles = [
+    'CLAUDE.md', 'constitution.md', 'core-config.yaml', 'manifest.yaml',
+    'manifest.json', 'framework-config.yaml', 'synapse-manifest.yaml',
+    'copy-surface-criteria.yaml', 'registry.yaml',
+    'CHANGELOG.md', 'COPY-CHIEF-INDEX.md', 'COPY-DOCS-INDEX.md',
+    'ecosystem-status.md', 'orchestrator.md', 'QUICK-REFERENCE.md',
+    'RUNBOOK.md', 'WORKFLOW-CANONICO.md',
+    'GUIA-ECOSSISTEMA.md', 'GUIA-INSTALACAO.md', 'GUIA-USO-ECOSSISTEMA.md',
+  ];
+  for (const file of rootFiles) {
+    const src = path.join(CLAUDE_HOME, file);
+    const dest = path.join(coreFramework, file);
+    if (fs.existsSync(src)) {
+      const srcStat = fs.statSync(src);
+      if (!fs.existsSync(dest) || srcStat.mtimeMs > fs.statSync(dest).mtimeMs) {
+        fs.copyFileSync(src, dest);
+        coreCount++;
+      }
+    }
+  }
+  log(`  copy-chief-black: ${coreCount} files synced`);
+
+  // 2. copy-chief-dashboard: ~/.claude/dashboard-v2/ → packages/copy-chief-dashboard/dashboard/
+  const dashSrc = path.join(CLAUDE_HOME, 'dashboard-v2');
+  const dashDest = path.join(PACKAGES, 'copy-chief-dashboard', 'dashboard');
+  let dashCount = 0;
+  if (fs.existsSync(dashSrc)) {
+    dashCount = syncDir(dashSrc, dashDest);
+  }
+  log(`  copy-chief-dashboard: ${dashCount} files synced`);
+
+  // 3. copywriting-mcp: ~/.claude/plugins/copywriting-mcp/ → packages/copywriting-mcp/server/
+  const mcpSrc = path.join(CLAUDE_HOME, 'plugins', 'copywriting-mcp');
+  const mcpDest = path.join(PACKAGES, 'copywriting-mcp', 'server');
+  let mcpCount = 0;
+  if (fs.existsSync(mcpSrc)) {
+    mcpCount = syncDir(mcpSrc, mcpDest);
+  }
+  log(`  copywriting-mcp: ${mcpCount} files synced`);
+
+  return { coreCount, dashCount, mcpCount };
+}
+
+// ── Git commit + push ─────────────────────────────────────────────
+function syncRepo(repoPath, repoName) {
+  const gitDir = path.join(repoPath, '.git');
+  if (!fs.existsSync(gitDir)) {
+    log(`SKIP: ${repoName} — not a git repo`);
+    return;
+  }
+
+  let hasDiff = false;
+  try {
+    execSync('git diff --quiet', { cwd: repoPath });
+    execSync('git diff --cached --quiet', { cwd: repoPath });
+  } catch (e) {
+    hasDiff = true;
+  }
+
+  if (!hasDiff) {
+    let untrackedCount = 0;
+    try {
+      const porcelain = execSync('git status --porcelain', { cwd: repoPath, encoding: 'utf8' });
+      const lines = porcelain.split('\n').filter(Boolean);
+      untrackedCount = lines.filter(l =>
+        l.startsWith('??') &&
+        !l.includes('plans/') &&
+        !l.includes('stats-cache') &&
+        !l.includes('history.jsonl')
+      ).length;
+    } catch (e) {
+      untrackedCount = 0;
+    }
+    if (untrackedCount === 0) {
+      log(`OK: ${repoName} — nothing to commit`);
+      return;
+    }
+  }
+
+  try {
+    execSync('git add -A', { cwd: repoPath });
+  } catch (e) { /* ignore */ }
+
+  const dateTime = new Date().toISOString().replace('T', ' ').slice(0, 16);
+  const msg = `chore: Auto-sync on session end (${dateTime})`;
+
+  try {
+    execSync(`git commit -m "${msg}"`, { cwd: repoPath });
+    log(`COMMIT: ${repoName}`);
+    try {
+      execSync('git push', { cwd: repoPath, timeout: 30000 });
+      log(`PUSH: ${repoName} OK`);
+    } catch (e) {
+      log(`PUSH: ${repoName} FAILED — ${e.message}`);
+    }
+  } catch (e) {
+    log(`SKIP: ${repoName} — nothing staged`);
+  }
+}
+
+// ══ Main ══════════════════════════════════════════════════════════
+log('=== Sync iniciado ===');
+
+// Phase 1: Sync source repos (as before)
+syncRepo(path.join(HOME, '.claude'), 'claude-ecosystem');
+syncRepo(path.join(HOME, 'copywriting-ecosystem'), 'copywriting-ecosystem');
+
+// Phase 2: Copy source → distribution packages
+syncDistribution();
+
+// Phase 3: Commit + push distribution repos
+syncRepo(path.join(PACKAGES, 'copy-chief-black'), 'copy-chief-black');
+syncRepo(path.join(PACKAGES, 'copy-chief-dashboard'), 'copy-chief-dashboard');
+syncRepo(path.join(PACKAGES, 'copywriting-mcp'), 'copywriting-mcp');
+
+log('=== Sync finalizado (5 repos) ===');
+
+process.exit(0);

package/framework/hooks/sync-repos-on-stop.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+#
+# sync-repos-on-stop.sh - Auto-sync repos when session ends
+# Hook: Stop
+#
+# Sincroniza ~/.claude e ~/copywriting-ecosystem automaticamente
+# Deploy Vercel se houver mudanças no site
+#
+
+# Cores
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+# Log silencioso (não polui output do usuário)
+LOG_FILE="/tmp/claude-sync-$(date +%Y%m%d).log"
+
+log() {
+    echo "[$(date '+%H:%M:%S')] $1" >> "$LOG_FILE"
+}
+
+sync_repo() {
+    local repo_path="$1"
+    local repo_name="$2"
+
+    if [ ! -d "$repo_path/.git" ]; then
+        log "SKIP: $repo_name não é git repo"
+        return 0
+    fi
+
+    cd "$repo_path" || return 1
+
+    # Verificar se há mudanças
+    if git diff --quiet && git diff --cached --quiet; then
+        # Verificar untracked files importantes (não includes plans/, stats, etc)
+        local untracked=$(git status --porcelain | grep -v "^?? plans/" | grep -v "stats-cache" | grep -v "history.jsonl" | grep "^??" | wc -l | tr -d ' ')
+        if [ "$untracked" -eq 0 ]; then
+            log "OK: $repo_name - nada para commitar"
+            return 0
+        fi
+    fi
+
+    # Commit automático
+    git add -A 2>/dev/null
+
+    local msg="chore: Auto-sync on session end ($(date '+%Y-%m-%d %H:%M'))"
+    if git commit -m "$msg" 2>/dev/null; then
+        log "COMMIT: $repo_name"
+
+        # Push
+        if git push 2>/dev/null; then
+            log "PUSH: $repo_name OK"
+        else
+            log "PUSH: $repo_name FAILED"
+        fi
+    else
+        log "SKIP: $repo_name - commit falhou ou nada staged"
+    fi
+}
+
+# Main
+log "=== Sync iniciado ==="
+
+# 1. Sync ~/.claude
+sync_repo "$HOME/.claude" "claude-ecosystem"
+
+# 2. Sync ~/copywriting-ecosystem
+sync_repo "$HOME/copywriting-ecosystem" "copywriting-ecosystem"
+
+# 3. Vercel deploy se necessário (já tratado pelo git hook post-commit)
+
+log "=== Sync finalizado ==="
+
+exit 0

package/framework/hooks/sync-site.cjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// sync-site.cjs - Auto-regenera site do ecossistema
+// v1.0 - Chamado pelo SessionEnd hook
+
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const HOME = os.homedir();
+const SITE_DIR = path.join(HOME, 'copywriting-ecosystem', 'site');
+const GENERATOR = path.join(SITE_DIR, 'generate.py');
+const OUTPUT = path.join(HOME, 'copywriting-ecosystem', 'index.html');
+const ECOSYSTEM_DIR = path.join(HOME, 'copywriting-ecosystem');
+
+// Verificar se gerador existe
+if (!fs.existsSync(GENERATOR)) {
+  process.stderr.write(`[SYNC-SITE] Gerador não encontrado: ${GENERATOR}\n`);
+  process.exit(0);
+}
+
+// Gerar site
+process.stderr.write('[SYNC-SITE] Regenerando site...\n');
+try {
+  const result = execSync(`python3 "${GENERATOR}"`, { cwd: ECOSYSTEM_DIR, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+  const lines = (result || '').split('\n').filter(Boolean);
+  for (const line of lines) {
+    process.stderr.write(`[SYNC-SITE] ${line}\n`);
+  }
+} catch (e) {
+  const errLines = ((e.stdout || '') + (e.stderr || '')).split('\n').filter(Boolean);
+  for (const line of errLines) {
+    process.stderr.write(`[SYNC-SITE] ${line}\n`);
+  }
+}
+
+// Verificar se houve mudanças
+try {
+  execSync(`git diff --quiet "${OUTPUT}"`, { cwd: ECOSYSTEM_DIR });
+  process.stderr.write('[SYNC-SITE] Site sem alterações\n');
+} catch (e) {
+  // git diff --quiet exits non-zero when there ARE changes
+  process.stderr.write('[SYNC-SITE] Site atualizado - commit automático\n');
+  try {
+    execSync(`git add "${OUTPUT}"`, { cwd: ECOSYSTEM_DIR });
+    const dateStr = new Date().toISOString().slice(0, 10);
+    execSync(`git commit -m "site: auto-update ${dateStr}"`, { cwd: ECOSYSTEM_DIR });
+  } catch (commitErr) {
+    // Ignore commit errors (e.g. nothing staged)
+  }
+}
+
+process.exit(0);

package/framework/hooks/sync-site.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# ~/.claude/hooks/sync-site.sh
+# v1.0 - Auto-regenera site do ecossistema
+# Chamado pelo SessionEnd hook
+
+SITE_DIR="$HOME/copywriting-ecosystem/site"
+GENERATOR="$SITE_DIR/generate.py"
+OUTPUT="$HOME/copywriting-ecosystem/index.html"
+
+# Verificar se gerador existe
+if [[ ! -f "$GENERATOR" ]]; then
+    echo "[SYNC-SITE] Gerador não encontrado: $GENERATOR" >&2
+    exit 0
+fi
+
+# Gerar site
+echo "[SYNC-SITE] Regenerando site..." >&2
+python3 "$GENERATOR" 2>&1 | while read -r line; do
+    echo "[SYNC-SITE] $line" >&2
+done
+
+# Verificar se houve mudanças
+cd "$HOME/copywriting-ecosystem" || exit 0
+
+if git diff --quiet "$OUTPUT" 2>/dev/null; then
+    echo "[SYNC-SITE] Site sem alterações" >&2
+else
+    echo "[SYNC-SITE] Site atualizado - commit automático" >&2
+    git add "$OUTPUT" 2>/dev/null
+    git commit -m "site: auto-update $(date +%Y-%m-%d)" 2>/dev/null || true
+fi
+
+exit 0

package/framework/hooks/template-header-validation.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+var import_template_validator = require("../.aios-core/copy-chief/quality/template-validator");
+const MAX_EXECUTION_MS = 2e3;
+const startTime = Date.now();
+async function main() {
+  let input;
+  try {
+    input = JSON.parse(require("fs").readFileSync(0, "utf8"));
+  } catch {
+    return;
+  }
+  if (Date.now() - startTime > MAX_EXECUTION_MS) return;
+  const result = (0, import_template_validator.runTemplateValidation)(input);
+  if (result?.warningMessage) {
+    console.error(result.warningMessage);
+  }
+  const elapsed = Date.now() - startTime;
+  if (elapsed > 1e3) {
+    console.error(`  \u23F1  template-header-validation took ${elapsed}ms (target: <${MAX_EXECUTION_MS}ms)`);
+  }
+}
+main().catch(() => {
+});

package/framework/hooks/template-header-validation.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+/**
+ * template-header-validation.ts — PreToolUse Hook (matcher: "Write|Edit")
+ * Part of AIOS: Automated Intelligence Operating System
+ *
+ * Thin wrapper. All business logic in:
+ * ~/.claude/.aios-core/copy-chief/quality/template-validator.ts
+ *
+ * Exit 0 always (warn-only, never blocks).
+ */
+
+import { runTemplateValidation } from "../.aios-core/copy-chief/quality/template-validator";
+
+const MAX_EXECUTION_MS = 2000;
+const startTime = Date.now();
+
+async function main(): Promise<void> {
+  let input: Record<string, unknown>;
+  try {
+    input = JSON.parse(require('fs').readFileSync(0, 'utf8') as string) as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  if (Date.now() - startTime > MAX_EXECUTION_MS) return;
+
+  const result = runTemplateValidation(input as Parameters<typeof runTemplateValidation>[0]);
+
+  if (result?.warningMessage) {
+    console.error(result.warningMessage);
+  }
+
+  const elapsed = Date.now() - startTime;
+  if (elapsed > 1000) {
+    console.error(`  ⏱  template-header-validation took ${elapsed}ms (target: <${MAX_EXECUTION_MS}ms)`);
+  }
+}
+
+main().catch(() => {
+  // Never crash, never block
+});