@lucapimenta/copy-chief-black 1.0.0

package/framework/hooks/persona-detector.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * Persona Detector
+ * Event: UserPromptSubmit
+ * Budget: <1s
+ *
+ * Detects @persona activation in user prompt and registers in active-agents.json.
+ * Fixes gap: top-level persona (not spawned via Agent()) was invisible to dashboard.
+ *
+ * AIOS pattern: deterministic detection → state write → dashboard reads.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Handle → internal agent ID mapping
+const HANDLE_TO_ID = {
+  chief: 'helix', helix: 'helix',
+  researcher: 'vox', vox: 'vox',
+  miner: 'cipher', cipher: 'cipher',
+  briefer: 'atlas', atlas: 'atlas',
+  vsl: 'echo', echo: 'echo',
+  lp: 'forge', forge: 'forge',
+  creative: 'scout', scout: 'scout',
+  producer: 'blade', blade: 'blade',
+  critic: 'hawk', hawk: 'hawk',
+  gatekeeper: 'sentinel', sentinel: 'sentinel',
+  ops: 'ops', operator: 'ops',
+  strategist: 'strategist',
+};
+
+const PERSONA_PATTERNS = [
+  // @handle at start or standalone
+  /^@(\w+)\b/i,
+  // "como @handle" or "ativa @handle"
+  /\b(?:como|ativa|activate|switch\s+to)\s+@(\w+)\b/i,
+];
+
+function detectPersona(prompt) {
+  if (!prompt || typeof prompt !== 'string') return null;
+  const trimmed = prompt.trim();
+  if (trimmed.length > 500) return null;
+
+  for (const pattern of PERSONA_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      const handle = match[1].toLowerCase();
+      if (HANDLE_TO_ID[handle]) return HANDLE_TO_ID[handle];
+    }
+  }
+  return null;
+}
+
+function detectOfferFromPrompt(prompt) {
+  const match = prompt.match(/\b(saude|relacionamento|concursos|financeiro|educacao|marketing-digital)\/([a-z][a-z0-9-]+)\b/);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+
+async function main() {
+  let input = '';
+  try {
+    input = fs.readFileSync(0, 'utf8');
+  } catch {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  let context = {};
+  try {
+    context = JSON.parse(input);
+  } catch {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const prompt = context.prompt || '';
+  const personaId = detectPersona(prompt);
+
+  if (!personaId) {
+    process.stdout.write(JSON.stringify({}));
+    return;
+  }
+
+  const stateDir = path.join(process.env.HOME, '.claude', 'session-state');
+  const setPath = path.join(stateDir, 'active-agents.json');
+  const offerPath = detectOfferFromPrompt(prompt);
+
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    // Read existing set
+    let agentSet = {};
+    try {
+      if (fs.existsSync(setPath)) {
+        agentSet = JSON.parse(fs.readFileSync(setPath, 'utf8'));
+      }
+    } catch { agentSet = {}; }
+
+    // Add/update this persona
+    agentSet[personaId] = {
+      offer: offerPath,
+      task: `Top-level: ${prompt.substring(0, 80).trim()}`,
+      timestamp: new Date().toISOString(),
+      activatedAt: Date.now(),
+      source: 'persona-detector',
+    };
+
+    fs.writeFileSync(setPath, JSON.stringify(agentSet, null, 2));
+
+    // Also write single marker for backwards compat
+    const markerPath = path.join(stateDir, 'active-persona.json');
+    fs.writeFileSync(markerPath, JSON.stringify({
+      persona: personaId,
+      offer: offerPath,
+      timestamp: new Date().toISOString(),
+      activatedAt: Date.now(),
+    }, null, 2));
+  } catch { /* non-critical */ }
+
+  // Emit dashboard event
+  try {
+    const dashUrl = process.env.DASHBOARD_URL || 'http://localhost:4001';
+    fetch(`${dashUrl}/events`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        type: 'AgentStart',
+        timestamp: Date.now(),
+        agent_id: personaId,
+        offer: offerPath,
+        task: `Top-level persona: @${personaId}`,
+        source: 'persona-detector',
+      }),
+      signal: AbortSignal.timeout(1000),
+    }).catch(() => {});
+  } catch { /* non-critical */ }
+
+  process.stdout.write(JSON.stringify({}));
+}
+
+main().catch(() => process.exit(0));

package/framework/hooks/persuasion-flow-check.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_persuasion_flow = require("../.aios-core/copy-chief/quality/persuasion-flow");
+const MAX_EXECUTION_MS = 3e3;
+const timeout = setTimeout(() => {
+  console.error("[FLOW-CHECK] \u23F0 Timeout \u2014 skipping");
+  process.exit(0);
+}, MAX_EXECUTION_MS);
+try {
+  const stdin = (0, import_fs.readFileSync)(0, "utf8");
+  const input = JSON.parse(stdin);
+  const result = (0, import_persuasion_flow.runPersuasionFlowCheck)(input);
+  if (result?.warningMessage) {
+    console.error(result.warningMessage);
+  }
+} catch (err) {
+  console.error(`[FLOW-CHECK] Error: ${err}`);
+}
+clearTimeout(timeout);
+process.exit(0);

package/framework/hooks/persuasion-flow-check.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+/**
+ * persuasion-flow-check.ts — PostToolUse Hook (matcher: "Write|Edit")
+ * Part of AIOS: Automated Intelligence Operating System
+ *
+ * Thin wrapper. All business logic in:
+ * ~/.claude/.aios-core/copy-chief/quality/persuasion-flow.ts
+ *
+ * Exit 0 always (warn-only, never blocks).
+ */
+
+import { readFileSync } from "fs";
+import { runPersuasionFlowCheck } from "../.aios-core/copy-chief/quality/persuasion-flow";
+
+const MAX_EXECUTION_MS = 3000;
+const timeout = setTimeout(() => {
+  console.error("[FLOW-CHECK] ⏰ Timeout — skipping");
+  process.exit(0);
+}, MAX_EXECUTION_MS);
+
+try {
+  const stdin = readFileSync(0, 'utf8');
+  const input = JSON.parse(stdin);
+
+  const result = runPersuasionFlowCheck(input);
+
+  if (result?.warningMessage) {
+    console.error(result.warningMessage);
+  }
+} catch (err) {
+  console.error(`[FLOW-CHECK] Error: ${err}`);
+}
+
+clearTimeout(timeout);
+process.exit(0);

package/framework/hooks/phase-advance-gate.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_path = require("path");
+var import_offer_state = require("../.aios-core/copy-chief/state/offer-state");
+var import_helix_phases = require("../.aios-core/copy-chief/workflow/helix-phases");
+var import_yaml_validator = require("../.aios-core/copy-chief/utils/yaml-validator");
+var import_phase_checklist = require("../.aios-core/copy-chief/workflow/phase-checklist");
+const ECOSYSTEM_ROOT = (0, import_path.join)(process.env.HOME, "copywriting-ecosystem");
+function allow() {
+  const output = {};
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+function block(reason, offerPath, phase, missingTools) {
+  const state = (0, import_offer_state.getOfferState)(offerPath);
+  const phaseKey = `phase_${phase}`;
+  const phaseState = state.helix_phases[phaseKey];
+  const toolsUsed = phaseState?.tools_used || [];
+  const toolsRequired = phaseState?.tools_required || [];
+  const output = {
+    decision: "block",
+    reason: `BLOQUEADO - FASE HELIX ${phase}
+
+${reason}
+
+**Estado da Oferta:** ${offerPath}
+**Fase:** ${phase}
+**Ferramentas Obrigatorias:** ${toolsRequired.map((t) => import_offer_state.TOOL_DISPLAY_NAMES[t] || t).join(", ")}
+**Ferramentas Usadas:** ${toolsUsed.length > 0 ? toolsUsed.map((t) => import_offer_state.TOOL_DISPLAY_NAMES[t] || t).join(", ") : "(nenhuma)"}
+**Ferramentas Faltando:** ${(missingTools || []).map((t) => import_offer_state.TOOL_DISPLAY_NAMES[t] || t).join(", ")}
+
+**ACAO OBRIGATORIA:**
+Execute as ferramentas faltantes ANTES de criar o arquivo da fase.
+
+**Por que isso existe (v8.0):**
+O sistema usa estado POR OFERTA (persistente entre sessoes).
+Isso garante que as ferramentas corretas foram usadas,
+mesmo se voce fechou e reabriu o Claude Code.
+Alem disso, um checklist de 3 camadas e gerado automaticamente
+ao avancar fase (reviews/phase-XX-review.md).
+
+Ver: ~/.claude/reference/tool-usage-matrix.md
+Estado: ${offerPath}/helix-state.yaml`
+  };
+  console.error(`[PHASE-ADVANCE-GATE] Blocked: Phase ${phase} - missing tools: ${(missingTools || []).join(", ")}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+async function main() {
+  try {
+    const stdin = (0, import_fs.readFileSync)(0, "utf8");
+    const input = JSON.parse(stdin);
+    if (input.tool_name !== "Write") {
+      allow();
+      return;
+    }
+    const filePath = input.tool_input?.file_path;
+    if (!filePath) {
+      allow();
+      return;
+    }
+    if (!filePath.includes("briefings/phases/") && !filePath.includes("briefings\\phases\\")) {
+      allow();
+      return;
+    }
+    const offerPath = (0, import_offer_state.detectOfferFromPath)(filePath);
+    if (!offerPath) {
+      console.error(`[PHASE-ADVANCE-GATE] Warning: Could not detect offer from path: ${filePath}`);
+      allow();
+      return;
+    }
+    const phase = (0, import_offer_state.detectPhaseFromPath)(filePath);
+    if (!phase) {
+      console.error(`[PHASE-ADVANCE-GATE] Warning: Could not detect phase from file: ${filePath}`);
+      allow();
+      return;
+    }
+    const helixStatePath = (0, import_path.join)(ECOSYSTEM_ROOT, offerPath, "helix-state.yaml");
+    if ((0, import_fs.existsSync)(helixStatePath)) {
+      const helixContent = (0, import_fs.readFileSync)(helixStatePath, "utf-8");
+      const yamlValidation = await (0, import_yaml_validator.validateYAML)(helixContent, "helix-state");
+      if (!yamlValidation.valid) {
+        const output = {
+          decision: "block",
+          reason: `BLOQUEADO - helix-state.yaml invalido
+
+Erro: ${yamlValidation.error}
+
+Corrija o arquivo antes de avancar a fase.
+${offerPath}/helix-state.yaml`
+        };
+        console.error(`[PHASE-ADVANCE-GATE] helix-state.yaml validation failed: ${yamlValidation.error}`);
+        console.log(JSON.stringify(output));
+        process.exit(0);
+        return;
+      }
+    }
+    const check = (0, import_offer_state.canWriteHelixPhase)(offerPath, phase);
+    if (!check.allowed) {
+      block(check.reason || "Ferramentas obrigatorias nao usadas", offerPath, phase, check.missingTools);
+      return;
+    }
+    const offerFullPath = (0, import_path.join)(ECOSYSTEM_ROOT, offerPath);
+    const prereqCheck = (0, import_helix_phases.isPhaseUnlocked)(phase, offerFullPath);
+    if (!prereqCheck.unlocked) {
+      console.error(`[PHASE-ADVANCE-GATE] Phase ${phase} prerequisites not met: ${prereqCheck.missingNames.join(", ")}`);
+    }
+    (0, import_phase_checklist.generatePhaseReviewChecklist)(offerPath, phase);
+    console.error(`[PHASE-ADVANCE-GATE] Phase ${phase} can be written - required tools used`);
+    allow();
+  } catch (error) {
+    console.error(`[PHASE-ADVANCE-GATE] Error: ${error}`);
+    allow();
+  }
+}
+main().catch((err) => {
+  console.error(`[PHASE-ADVANCE-GATE] Fatal error: ${err}`);
+  process.exit(0);
+});

package/framework/hooks/phase-advance-gate.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+// ~/.claude/hooks/phase-advance-gate.ts
+// Hook PreToolUse para Write em briefings/phases/
+// v8.0 - Thin wrapper (checklist logic in copy-chief/workflow/phase-checklist.ts)
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import {
+  detectOfferFromPath,
+  detectPhaseFromPath,
+  canWriteHelixPhase,
+  getOfferState,
+  TOOL_DISPLAY_NAMES,
+} from '../.aios-core/copy-chief/state/offer-state';
+import { isPhaseUnlocked } from '../.aios-core/copy-chief/workflow/helix-phases';
+import { validateYAML } from '../.aios-core/copy-chief/utils/yaml-validator';
+import { generatePhaseReviewChecklist } from '../.aios-core/copy-chief/workflow/phase-checklist';
+
+const ECOSYSTEM_ROOT = join(process.env.HOME!, 'copywriting-ecosystem');
+
+interface PreToolUseInput {
+  tool_name: string;
+  tool_input: Record<string, unknown>;
+}
+
+interface PreToolUseOutput {
+  decision?: 'block' | 'allow';
+  reason?: string;
+}
+
+function allow(): void {
+  const output: PreToolUseOutput = {};
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+function block(reason: string, offerPath: string, phase: number, missingTools?: string[]): void {
+  const state = getOfferState(offerPath);
+  const phaseKey = `phase_${phase}`;
+  const phaseState = state.helix_phases[phaseKey];
+
+  const toolsUsed = phaseState?.tools_used || [];
+  const toolsRequired = phaseState?.tools_required || [];
+
+  const output: PreToolUseOutput = {
+    decision: 'block',
+    reason: `BLOQUEADO - FASE HELIX ${phase}
+
+${reason}
+
+**Estado da Oferta:** ${offerPath}
+**Fase:** ${phase}
+**Ferramentas Obrigatorias:** ${toolsRequired.map(t => TOOL_DISPLAY_NAMES[t] || t).join(', ')}
+**Ferramentas Usadas:** ${toolsUsed.length > 0 ? toolsUsed.map(t => TOOL_DISPLAY_NAMES[t] || t).join(', ') : '(nenhuma)'}
+**Ferramentas Faltando:** ${(missingTools || []).map(t => TOOL_DISPLAY_NAMES[t] || t).join(', ')}
+
+**ACAO OBRIGATORIA:**
+Execute as ferramentas faltantes ANTES de criar o arquivo da fase.
+
+**Por que isso existe (v8.0):**
+O sistema usa estado POR OFERTA (persistente entre sessoes).
+Isso garante que as ferramentas corretas foram usadas,
+mesmo se voce fechou e reabriu o Claude Code.
+Alem disso, um checklist de 3 camadas e gerado automaticamente
+ao avancar fase (reviews/phase-XX-review.md).
+
+Ver: ~/.claude/reference/tool-usage-matrix.md
+Estado: ${offerPath}/helix-state.yaml`,
+  };
+
+  console.error(`[PHASE-ADVANCE-GATE] Blocked: Phase ${phase} - missing tools: ${(missingTools || []).join(', ')}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+
+async function main(): Promise<void> {
+  try {
+    const stdin = readFileSync(0, 'utf8');
+    const input: PreToolUseInput = JSON.parse(stdin);
+
+    // Only process Write
+    if (input.tool_name !== 'Write') {
+      allow();
+      return;
+    }
+
+    const filePath = input.tool_input?.file_path as string;
+    if (!filePath) {
+      allow();
+      return;
+    }
+
+    // Only check HELIX phase files
+    if (!filePath.includes('briefings/phases/') && !filePath.includes('briefings\\phases\\')) {
+      allow();
+      return;
+    }
+
+    // Detect offer from path
+    const offerPath = detectOfferFromPath(filePath);
+    if (!offerPath) {
+      console.error(`[PHASE-ADVANCE-GATE] Warning: Could not detect offer from path: ${filePath}`);
+      allow();
+      return;
+    }
+
+    // Detect phase from file name
+    const phase = detectPhaseFromPath(filePath);
+    if (!phase) {
+      console.error(`[PHASE-ADVANCE-GATE] Warning: Could not detect phase from file: ${filePath}`);
+      allow();
+      return;
+    }
+
+    // Validate helix-state.yaml before allowing phase advance
+    const helixStatePath = join(ECOSYSTEM_ROOT, offerPath, 'helix-state.yaml');
+    if (existsSync(helixStatePath)) {
+      const helixContent = readFileSync(helixStatePath, 'utf-8');
+      const yamlValidation = await validateYAML(helixContent, 'helix-state');
+      if (!yamlValidation.valid) {
+        const output: PreToolUseOutput = {
+          decision: 'block',
+          reason: `BLOQUEADO - helix-state.yaml invalido\n\nErro: ${yamlValidation.error}\n\nCorrija o arquivo antes de avancar a fase.\n${offerPath}/helix-state.yaml`,
+        };
+        console.error(`[PHASE-ADVANCE-GATE] helix-state.yaml validation failed: ${yamlValidation.error}`);
+        console.log(JSON.stringify(output));
+        process.exit(0);
+        return;
+      }
+    }
+
+    // Check if this phase can be written (using OFFER state)
+    const check = canWriteHelixPhase(offerPath, phase);
+    if (!check.allowed) {
+      block(check.reason || 'Ferramentas obrigatorias nao usadas', offerPath, phase, check.missingTools);
+      return;
+    }
+
+    // Additional check: verify phase prerequisites via helix-phases
+    const offerFullPath = join(ECOSYSTEM_ROOT, offerPath);
+    const prereqCheck = isPhaseUnlocked(phase, offerFullPath);
+    if (!prereqCheck.unlocked) {
+      console.error(`[PHASE-ADVANCE-GATE] Phase ${phase} prerequisites not met: ${prereqCheck.missingNames.join(', ')}`);
+      // Warn but don't block (tool-based gate is primary)
+    }
+
+    // All checks passed — delegate checklist generation to module
+    generatePhaseReviewChecklist(offerPath, phase);
+
+    console.error(`[PHASE-ADVANCE-GATE] Phase ${phase} can be written - required tools used`);
+    allow();
+
+  } catch (error) {
+    console.error(`[PHASE-ADVANCE-GATE] Error: ${error}`);
+    allow(); // Fail-open on error
+  }
+}
+
+main().catch(err => {
+  console.error(`[PHASE-ADVANCE-GATE] Fatal error: ${err}`);
+  process.exit(0); // Fail-open
+});

package/framework/hooks/phase-gate.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+var import_fs = require("fs");
+var import_gate_resolver = require("../.aios-core/copy-chief/gates/gate-resolver");
+var import_session_state = require("../.aios-core/copy-chief/state/session-state");
+function main() {
+  try {
+    const stdin = (0, import_fs.readFileSync)(0, "utf8");
+    const input = JSON.parse(stdin);
+    const toolName = input.tool_name;
+    if (!["Write", "Edit", "MultiEdit", "NotebookEdit"].includes(toolName)) {
+      allow();
+      return;
+    }
+    const filePath = extractFilePath(input.tool_input);
+    if (!filePath) {
+      allow();
+      return;
+    }
+    const check = (0, import_gate_resolver.resolveCanWriteToPath)(filePath);
+    if (check.debug) {
+      console.error(`[PHASE-GATE] Resolu\xE7\xE3o para ${filePath}:`);
+      console.error(`  - Oferta: ${check.offerPath || "n\xE3o detectada"}`);
+      console.error(`  - Fonte: ${check.source}`);
+      console.error(`  - offer-state: ${check.debug.offerStateChecked ? check.debug.offerGatePassed ? "PASSED" : "NOT PASSED" : "n\xE3o verificado"}`);
+      console.error(`  - session-state: ${check.debug.sessionStateChecked ? check.debug.sessionGatePassed ? "PASSED" : "NOT PASSED" : "n\xE3o verificado"}`);
+      console.error(`  - heur\xEDstica: ${check.debug.heuristicChecked ? check.debug.heuristicPassed ? "PASSED" : "NOT PASSED" : "n\xE3o verificado"}`);
+    }
+    if (!check.allowed) {
+      block(check.reason || "Gate n\xE3o passou", check.requiredGate, check.source);
+      return;
+    }
+    if (check.offerPath && (check.source === "offer-state" || check.source === "heuristic")) {
+      (0, import_gate_resolver.syncSessionFromOffer)(check.offerPath);
+    }
+    allow();
+  } catch (error) {
+    console.error(`[PHASE-GATE] Erro: ${error}`);
+    allow();
+  }
+}
+function extractFilePath(toolInput) {
+  const possibleFields = ["file_path", "path", "notebook_path", "filePath"];
+  for (const field of possibleFields) {
+    if (typeof toolInput[field] === "string") {
+      return toolInput[field];
+    }
+  }
+  return null;
+}
+function allow() {
+  const output = {};
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+function block(reason, requiredGate, source) {
+  const state = (0, import_session_state.getSessionState)();
+  const gates = (0, import_session_state.getGatesStatus)();
+  const phase = (0, import_session_state.getCurrentPhase)();
+  const offer = (0, import_session_state.getActiveOffer)();
+  const output = {
+    decision: "block",
+    reason: `\u{1F6AB} BLOQUEADO - GATE N\xC3O PASSOU
+
+${reason}
+
+**Estado Atual (v7.1 Dual-Source):**
+- Oferta: ${offer || "n\xE3o definida"}
+- Fase: ${phase}
+- Gates (session): research=${gates.research}, briefing=${gates.briefing}, production=${gates.production}
+- Fonte da verifica\xE7\xE3o: ${source || "session-state"}
+
+**A\xC7\xC3O OBRIGAT\xD3RIA:**
+${requiredGate ? getActionForGate(requiredGate, offer) : "Execute o gate necess\xE1rio antes de continuar."}
+
+**Por que isso existe:**
+O sistema v7.1 usa fallback chain para resolver gates:
+1. offer-state (helix-state.yaml) - PERSISTENTE
+2. session-state - VOL\xC1TIL (2h)
+3. heur\xEDstica (arquivos existem) - \xDALTIMO RECURSO
+
+RESEARCH \u2192 validate_gate("research") \u2192 BRIEFING
+BRIEFING \u2192 validate_gate("briefing") \u2192 PRODUCTION
+PRODUCTION \u2192 black_validation(score\u22658) \u2192 DELIVERED
+
+Ver: ~/.claude/reference/tool-usage-matrix.md`
+  };
+  console.error(`[PHASE-GATE] Bloqueado (fonte: ${source || "session-state"}): ${reason}`);
+  console.log(JSON.stringify(output));
+  process.exit(0);
+}
+function getActionForGate(gate, offer) {
+  const offerPath = offer || "[caminho-da-oferta]";
+  switch (gate) {
+    case "research":
+      return `Execute validate_gate para research:
+\`\`\`
+mcp__copywriting__validate_gate(gate_type="research", offer_path="${offerPath}")
+\`\`\`
+
+Isso verifica se todos os deliverables de research existem:
+- research/voc/summary.md
+- research/competitors/summary.md
+- research/mechanism/summary.md
+- research/avatar/summary.md
+- research/synthesis.md`;
+    case "briefing":
+      return `Execute validate_gate para briefing:
+\`\`\`
+mcp__copywriting__validate_gate(gate_type="briefing", offer_path="${offerPath}")
+\`\`\`
+
+Isso verifica se todas as 10 fases HELIX est\xE3o completas.`;
+    case "production":
+      return `Execute black_validation na copy final:
+\`\`\`
+mcp__copywriting__black_validation(copy="[sua copy]", copy_type="vsl|lp|creative")
+\`\`\`
+
+Score \u22658 \xE9 necess\xE1rio para passar.`;
+    default:
+      return "Execute o gate apropriado antes de continuar.";
+  }
+}
+main();