@creative-ia/cortex 1.0.5

package/dist/tools/semantic-search.d.ts

@@ -0,0 +1,7 @@
+import { type License } from "../config/license.js";
+export declare function semanticSearch(params: {
+    query: string;
+    domain?: string;
+    limit?: number;
+    license?: License;
+}): Promise<string>;

package/dist/tools/semantic-search.js

@@ -0,0 +1,68 @@
+/**
+ * Tool MCP: semantic_search — Busca semântica no knowledge base via Bedrock Embeddings.
+ *
+ * Fluxo:
+ * 1. Gera embedding da query do usuário
+ * 2. Carrega todos os registros do(s) domain(s)
+ * 3. Gera embedding de cada registro (título + conteúdo truncado)
+ * 4. Calcula cosine similarity
+ * 5. Retorna top-N mais relevantes
+ *
+ * Cache: embeddings são gerados on-the-fly (dataset pequeno, ~100 registros).
+ * Para datasets maiores, considerar cache em DynamoDB.
+ */
+import { getEmbedding, cosineSimilarity } from "../knowledge/embeddings.js";
+import { queryByDomain } from "../knowledge/dynamo-store.js";
+import { filterAllowedDomains } from "../config/license.js";
+const ALL_DOMAINS = [
+    "decisions", "changelog", "troubleshooting", "glossary",
+    "integrations", "lessons-learned", "pending", "ports",
+    "stakeholders", "environments",
+];
+export async function semanticSearch(params) {
+    const limit = params.limit || 5;
+    const allDomains = params.domain ? [params.domain] : ALL_DOMAINS;
+    const domains = params.license ? filterAllowedDomains(params.license, allDomains) : allDomains;
+    // 1. Get query embedding
+    const queryEmb = await getEmbedding(params.query);
+    // 2. Load all entries from target domains
+    const allEntries = [];
+    for (const d of domains) {
+        const entries = await queryByDomain(d, 200);
+        allEntries.push(...entries);
+    }
+    if (allEntries.length === 0) {
+        return "Nenhum registro encontrado nos domains selecionados.";
+    }
+    // 3. Score each entry
+    const scored = [];
+    for (const entry of allEntries) {
+        const text = `${entry.title}. ${entry.content.slice(0, 500)}`;
+        try {
+            const entryEmb = await getEmbedding(text);
+            const score = cosineSimilarity(queryEmb, entryEmb);
+            scored.push({ entry, score });
+        }
+        catch {
+            // Skip entries that fail embedding
+        }
+    }
+    // 4. Sort by similarity and take top-N
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, limit);
+    if (top.length === 0) {
+        return "Não foi possível calcular similaridade para os registros.";
+    }
+    // 5. Format results
+    const lines = [`## Semantic Search: "${params.query}" (top ${top.length})\n`];
+    for (const { entry, score } of top) {
+        const pct = (score * 100).toFixed(1);
+        lines.push(`### [${entry.domain}] ${entry.id} — ${entry.title} (${pct}% match)`);
+        const preview = entry.content.length > 300 ? entry.content.slice(0, 300) + "..." : entry.content;
+        lines.push(preview);
+        if (entry.tags?.length)
+            lines.push(`Tags: ${entry.tags.join(", ")}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/tools/update-process.d.ts

@@ -0,0 +1,17 @@
+interface UpdateProcessRequest {
+    processId: string;
+    updates: {
+        tech_stack?: Record<string, string>;
+        decisions?: Array<{
+            title: string;
+            decision: string;
+            rationale?: string;
+        }>;
+        phase_status?: Record<string, string>;
+        notes?: string;
+        stakeholder?: string;
+    };
+    listProcesses?: boolean;
+}
+export declare function updateProcess(params: UpdateProcessRequest): Promise<string>;
+export {};

package/dist/tools/update-process.js

@@ -0,0 +1,195 @@
+/**
+ * Tool: update_process
+ * Acrescenta informações a um processo existente.
+ *
+ * Fluxo:
+ * 1. Busca processo no DynamoDB pelo processId
+ * 2. Valida que o processo existe
+ * 3. Aplica as atualizações (tech_stack, decisions, phase_status, notes)
+ * 4. Atualiza DynamoDB
+ * 5. Retorna conteúdo atualizado com marcadores CREATE_FILE para o MCP client
+ */
+import { getEntry, putEntry, queryByDomain } from "../knowledge/dynamo-store.js";
+/**
+ * Lista processos acessíveis pela licença (domain: processes).
+ */
+async function listAccessibleProcesses() {
+    const entries = await queryByDomain("processes", 50);
+    if (entries.length === 0)
+        return "Nenhum processo encontrado.";
+    const lines = ["## Processos Disponíveis", ""];
+    lines.push("| UUID | Título | Status | Stakeholder |");
+    lines.push("|------|--------|--------|-------------|");
+    for (const entry of entries) {
+        let content;
+        try {
+            content = JSON.parse(entry.content);
+        }
+        catch {
+            continue;
+        }
+        const uuid = content.uuid || entry.id.replace("PROC-", "");
+        const status = content.status || "unknown";
+        const stakeholder = content.stakeholder || "—";
+        lines.push(`| ${uuid} | ${entry.title} | ${status} | ${stakeholder} |`);
+    }
+    return lines.join("\n");
+}
+export async function updateProcess(params) {
+    const { processId, updates, listProcesses: shouldList } = params;
+    // Se pediu para listar, retorna lista
+    if (shouldList) {
+        return listAccessibleProcesses();
+    }
+    // Busca processo
+    const procId = processId.startsWith("PROC-") ? processId : `PROC-${processId}`;
+    const entry = await getEntry("processes", procId);
+    if (!entry) {
+        // Tenta listar processos disponíveis para ajudar
+        const list = await listAccessibleProcesses();
+        return `Processo "${processId}" não encontrado.\n\n${list}`;
+    }
+    // Parse conteúdo existente
+    let content;
+    try {
+        content = JSON.parse(entry.content);
+    }
+    catch {
+        return `Erro ao parsear conteúdo do processo ${processId}.`;
+    }
+    const out = [];
+    const date = new Date().toISOString().slice(0, 10);
+    // --- Aplica tech_stack ---
+    if (updates.tech_stack) {
+        content.tech_stack = { ...(content.tech_stack || {}), ...updates.tech_stack };
+        out.push("✅ Tech stack atualizado");
+    }
+    // --- Aplica decisions ---
+    if (updates.decisions && updates.decisions.length > 0) {
+        if (!content.decisions)
+            content.decisions = [];
+        for (const dec of updates.decisions) {
+            const nextId = `DEC-${String(content.decisions.length + 1).padStart(3, "0")}`;
+            content.decisions.push({
+                id: nextId,
+                date,
+                title: dec.title,
+                decision: dec.decision,
+                rationale: dec.rationale,
+            });
+        }
+        out.push(`✅ ${updates.decisions.length} decisão(ões) adicionada(s)`);
+    }
+    // --- Aplica phase_status ---
+    if (updates.phase_status) {
+        for (const [phase, status] of Object.entries(updates.phase_status)) {
+            if (content.phases[phase] !== undefined) {
+                content.phases[phase] = status;
+            }
+        }
+        out.push("✅ Status de fases atualizado");
+    }
+    // --- Aplica notes ---
+    if (updates.notes) {
+        if (!content.notes)
+            content.notes = [];
+        content.notes.push(`[${date}] ${updates.notes}`);
+        out.push("✅ Nota adicionada");
+    }
+    // --- Aplica stakeholder ---
+    if (updates.stakeholder) {
+        content.stakeholder = updates.stakeholder;
+        out.push("✅ Stakeholder atualizado");
+    }
+    // --- Atualiza status geral ---
+    const phaseValues = Object.values(content.phases);
+    if (phaseValues.every(s => s === "done")) {
+        content.status = "completed";
+    }
+    else if (phaseValues.some(s => s === "in_progress" || s === "done")) {
+        content.status = "in_progress";
+    }
+    // --- Persiste no DynamoDB ---
+    const techSummary = content.tech_stack
+        ? Object.values(content.tech_stack).join(" | ")
+        : "";
+    await putEntry({
+        domain: "processes",
+        id: procId,
+        title: entry.title,
+        content: JSON.stringify(content),
+        tags: entry.tags || ["process", "active"],
+        metadata: {
+            stakeholder: content.stakeholder,
+            createdBy: "mcp-server",
+            status: content.status,
+            ...(techSummary && { tech_stack: techSummary }),
+        },
+        created_at: entry.created_at,
+        updated_at: new Date().toISOString(),
+    });
+    // --- Gera arquivos locais atualizados ---
+    const basePath = content.localPath || `orquestrador/creative-main/process/${content.uuid}`;
+    // knowledge.json atualizado
+    const knowledgeJson = JSON.stringify({
+        process_id: content.uuid,
+        version: "1.1.0",
+        title: `Knowledge Base — ${entry.title}`,
+        created_at: entry.created_at?.slice(0, 10) || date,
+        updated_at: date,
+        status: content.status,
+        meetings: [],
+        decisions: content.decisions || [],
+        questions: [],
+        context: content.tech_stack ? [{
+                id: "CTX-001",
+                date,
+                title: "Tech Stack",
+                content: techSummary,
+            }] : [],
+        learnings: [],
+        notes: content.notes || [],
+    }, null, 2);
+    // orchestration.json atualizado
+    const orchestrationJson = JSON.stringify({
+        process_id: content.uuid,
+        version: "1.1.0",
+        created_at: entry.created_at?.slice(0, 10) || date,
+        phases: Object.fromEntries(Object.entries(content.phases).map(([k, v]) => [
+            k.replace(/^\d+-/, ""),
+            {
+                status: v,
+                started_at: v !== "pending" ? date : null,
+                completed_at: v === "done" ? date : null,
+            },
+        ])),
+        ...(content.tech_stack && { tech_stack: content.tech_stack }),
+        repos: [],
+        sessions: [{ date, type: "update_process", summary: out.join(", ") }],
+    }, null, 2);
+    // Monta output com marcadores CREATE_FILE
+    const result = [
+        `## Processo ${content.uuid} — Atualizado`,
+        "",
+        ...out,
+        "",
+        `DynamoDB: [processes] ${procId} ✅`,
+        "",
+        "---",
+        "",
+        "## 📁 Arquivos Locais (atualizar automaticamente)",
+        "",
+        `> Diretório base: \`${basePath}/\``,
+        "",
+        `<!-- CREATE_FILE: ${basePath}/knowledge.json -->`,
+        "```json",
+        knowledgeJson,
+        "```",
+        "",
+        `<!-- CREATE_FILE: ${basePath}/orchestration.json -->`,
+        "```json",
+        orchestrationJson,
+        "```",
+    ];
+    return result.join("\n");
+}

package/dist/tools/validate-idea.d.ts

@@ -0,0 +1,7 @@
+interface ValidateIdeaRequest {
+    idea: string;
+    context?: string;
+    processId?: string;
+}
+export declare function validateIdea(params: ValidateIdeaRequest): Promise<string>;
+export {};

package/dist/tools/validate-idea.js

@@ -0,0 +1,339 @@
+/**
+ * Tool: validate_idea
+ * Recebe uma ideia em linguagem natural e retorna análise de viabilidade
+ * consultando internamente: domínios, integrações, arquitetura, processos anteriores.
+ * O cliente NUNCA vê o knowledge bruto — recebe apenas o parecer processado.
+ */
+import { loadCodeStandards, loadIntegrations, loadDecisions, loadIndex } from "../knowledge/loader.js";
+const DOMAINS = [
+    { name: "Identity", type: "core", squad: "Squad Identity" },
+    { name: "Onboarding", type: "core", squad: "Squad Aquisicao" },
+    { name: "Cards", type: "core", squad: "Squad Cartoes" },
+    { name: "Wallet", type: "core", squad: "Squad Cartoes" },
+    { name: "Growth", type: "core", squad: "Squad Aquisicao" },
+    { name: "Accounts", type: "supporting", squad: "Squad Contas" },
+    { name: "Transactions", type: "supporting", squad: "Squad Financeiro" },
+    { name: "Billing", type: "supporting", squad: "Squad Financeiro" },
+    { name: "Collections", type: "supporting", squad: "Squad Pos-Venda" },
+    { name: "Disputes", type: "supporting", squad: "Squad Pos-Venda" },
+    { name: "Notifications", type: "supporting", squad: "Squad Platform" },
+    { name: "Platform", type: "generic", squad: "Squad Platform" },
+    { name: "Design System", type: "generic", squad: "Squad Design" },
+];
+// Keywords que mapeiam para domínios e integrações
+const KEYWORD_MAP = {
+    // Domínios
+    "credito": ["Billing", "Transactions", "Collections"],
+    "consignado": ["Billing", "Transactions", "Collections"],
+    "inss": ["Billing", "Identity"],
+    "emprestimo": ["Billing", "Transactions"],
+    "cartao": ["Cards", "Wallet"],
+    "conta": ["Accounts", "Identity"],
+    "onboarding": ["Onboarding", "Identity"],
+    "cadastro": ["Onboarding", "Identity"],
+    "pagamento": ["Transactions", "Billing"],
+    "pix": ["Transactions", "Wallet"],
+    "transferencia": ["Transactions", "Wallet"],
+    "notificacao": ["Notifications"],
+    "push": ["Notifications"],
+    "sms": ["Notifications"],
+    "app": ["Design System", "Platform"],
+    "jornada": ["Onboarding", "Design System"],
+    "consorcio": ["Billing", "Collections"],
+    "seguro": ["Billing"],
+    "investimento": ["Transactions", "Wallet"],
+    "cobranca": ["Collections", "Billing"],
+    "disputa": ["Disputes"],
+    "fatura": ["Billing", "Cards"],
+    // Integrações
+    "pismo": ["Pismo"],
+    "embracon": ["Embracon"],
+    "visa": ["Pismo"],
+    "mastercard": ["Pismo"],
+};
+function detectKeywords(text) {
+    const lower = text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    const domains = new Set();
+    const integrations = new Set();
+    for (const [keyword, targets] of Object.entries(KEYWORD_MAP)) {
+        if (lower.includes(keyword)) {
+            for (const t of targets) {
+                const domain = DOMAINS.find((d) => d.name === t);
+                if (domain)
+                    domains.add(t);
+                else
+                    integrations.add(t);
+            }
+        }
+    }
+    return { domains, integrations };
+}
+export async function validateIdea(params) {
+    const { idea } = params;
+    // 1. Detect domains and integrations from the idea text
+    const detected = detectKeywords(idea);
+    // 2. Load knowledge (internal — never exposed)
+    const [integrations, decisions, index, standards] = await Promise.all([
+        loadIntegrations().catch(() => ({ entries: [] })),
+        loadDecisions().catch(() => ({ entries: [] })),
+        loadIndex().catch(() => ({ processes_with_knowledge: [] })),
+        loadCodeStandards().catch(() => ({ levels: {} })),
+    ]);
+    const intEntries = integrations.entries || [];
+    const decEntries = decisions.entries || [];
+    const processes = index.processes_with_knowledge || [];
+    // 3. Find relevant integrations
+    const relevantIntegrations = intEntries.filter((i) => detected.integrations.has(i.name) ||
+        detected.domains.has(i.name) ||
+        (i.domains && i.domains.some((d) => {
+            const lower = idea.toLowerCase();
+            return lower.includes(d.toLowerCase());
+        })));
+    // 4. Find relevant past processes
+    const relevantProcesses = processes.filter((p) => {
+        const lower = idea.toLowerCase();
+        return lower.includes("cartao") && p.title?.toLowerCase().includes("cartao") ||
+            lower.includes("pismo") && p.title?.toLowerCase().includes("pismo") ||
+            lower.includes("legado") && p.title?.toLowerCase().includes("legado");
+    });
+    // 5. Find relevant decisions
+    const relevantDecisions = decEntries.filter((d) => {
+        const tags = (d.tags || []).join(" ").toLowerCase();
+        return [...detected.domains].some((dom) => tags.includes(dom.toLowerCase())) ||
+            d.tags?.includes("arquitetura") || d.tags?.includes("workflow");
+    });
+    // 6. Identify affected squads
+    const affectedSquads = new Set();
+    for (const domName of detected.domains) {
+        const dom = DOMAINS.find((d) => d.name === domName);
+        if (dom)
+            affectedSquads.add(dom.squad);
+    }
+    // 7. Determine if new domain is needed
+    const isNewProduct = !detected.domains.size ||
+        idea.toLowerCase().includes("novo produto") ||
+        idea.toLowerCase().includes("nova jornada");
+    // 8. Build the feasibility report
+    const out = [];
+    out.push("# Parecer de Viabilidade");
+    out.push("");
+    out.push(`## Ideia Analisada`);
+    out.push(`> ${idea}`);
+    out.push("");
+    // Domains
+    out.push("## 1. Dominios Impactados");
+    if (detected.domains.size > 0) {
+        for (const domName of detected.domains) {
+            const dom = DOMAINS.find((d) => d.name === domName);
+            if (dom) {
+                out.push(`- **${dom.name}** (${dom.type}) — ${dom.squad}`);
+            }
+        }
+    }
+    else {
+        out.push("- Nenhum dominio existente mapeado. Pode exigir criacao de novo dominio.");
+    }
+    out.push("");
+    // Squads
+    out.push("## 2. Squads Envolvidas");
+    if (affectedSquads.size > 0) {
+        for (const squad of affectedSquads)
+            out.push(`- ${squad}`);
+        out.push("- Squad Platform (transversal — infra, autenticacao, notificacoes)");
+        out.push("- Squad Design (transversal — Design System, UX)");
+    }
+    else {
+        out.push("- A definir apos mapeamento de dominios");
+    }
+    out.push("");
+    // Architecture
+    out.push("## 3. Arquitetura Recomendada");
+    out.push("Baseado nos padroes L3 da BU:");
+    out.push("- Camada BFF: Node/TypeScript (config, domain, services, clients, resolvers, middleware, shared)");
+    out.push("- Camada Backend: Java Spring (config, domain, service, controller, infrastructure, dto, exception)");
+    out.push("- Camada Frontend: React/RN (components, pages, hooks, services, store, types, utils)");
+    out.push("- Separacao de camadas: apresentacao > aplicacao > dominio > infraestrutura > compartilhado");
+    out.push("- Injecao de Dependencia obrigatoria para I/O");
+    out.push("- Tratamento de erros: hierarquia AppError (DomainError, ValidationError, InfrastructureError)");
+    out.push("");
+    // Integrations
+    out.push("## 4. Integracoes Necessarias");
+    if (relevantIntegrations.length > 0) {
+        for (const int of relevantIntegrations) {
+            out.push(`- **${int.name}** (${int.type}) — situacao: ${int.status}`);
+            if (int.domains)
+                out.push(`  Dominios: ${int.domains.join(", ")}`);
+            if (int.auth)
+                out.push(`  Autenticacao: ${int.auth}`);
+        }
+    }
+    if (idea.toLowerCase().includes("inss")) {
+        out.push("- **INSS/Dataprev** (nova integracao) — API de margem consignavel, averbacao");
+        out.push("  Requer: conveniencia com orgao pagador, certificado digital, homologacao");
+    }
+    if (idea.toLowerCase().includes("consignado")) {
+        out.push("- **Banco correspondente** (nova integracao) — originacao de credito, cessao");
+        out.push("  Requer: contrato de correspondente bancario, regulamentacao BACEN");
+    }
+    out.push("");
+    // Past processes
+    out.push("## 5. Processos Anteriores Relevantes");
+    if (relevantProcesses.length > 0) {
+        for (const p of relevantProcesses) {
+            out.push(`- **${p.process_id}** — ${p.title} (${p.status})`);
+        }
+        out.push("  Licoes aprendidas destes processos serao consideradas.");
+    }
+    else {
+        out.push("- Nenhum processo anterior diretamente relacionado.");
+        out.push("- Este sera um processo pioneiro na BU para este dominio.");
+    }
+    out.push("");
+    // Relevant decisions
+    out.push("## 6. Decisoes Existentes Aplicaveis");
+    if (relevantDecisions.length > 0) {
+        for (const d of relevantDecisions) {
+            out.push(`- **${d.id}**: ${d.title}`);
+        }
+    }
+    else {
+        out.push("- Nenhuma decisao anterior diretamente aplicavel.");
+    }
+    out.push("");
+    // Quality requirements
+    out.push("## 7. Requisitos de Qualidade (automaticos)");
+    out.push("Aplicacao automatica dos 35 padroes L1-L4:");
+    out.push("- L1: Complexidade ciclomatica max 10, funcoes max 30 linhas, max 4 parametros");
+    out.push("- L2: Cobertura unitaria >= 80%, integracao >= 60%, E2E 100% caminhos felizes");
+    out.push("- L3: Separacao de camadas, Injecao de Dependencia, tratamento de erros, contratos de API padronizados");
+    out.push("- L4: Validacao de entrada (Zod/Bean), sem segredos no codigo, OWASP Top 10, LGPD");
+    out.push("- Portao de qualidade: SonarQube (nota A) + Snyk (zero critico/alto)");
+    out.push("");
+    // Risks
+    out.push("## 8. Riscos Identificados");
+    const risks = [];
+    if (idea.toLowerCase().includes("inss"))
+        risks.push("- **Regulatorio**: Integracao INSS exige conveniencia e homologacao (prazo 60-90 dias)");
+    if (idea.toLowerCase().includes("consignado"))
+        risks.push("- **Regulatorio**: Credito consignado exige correspondente bancario (Res. BACEN 4935)");
+    if (idea.toLowerCase().includes("app"))
+        risks.push("- **UX**: Jornada no app existente exige alinhamento com Design System atual");
+    if (isNewProduct)
+        risks.push("- **Dominio**: Novo produto pode exigir criacao de dominio (registrar em domain-steering)");
+    risks.push("- **Seguranca**: Dados financeiros + CPF exigem conformidade total com LGPD (L4-006)");
+    risks.push("- **Integracao**: APIs externas novas exigem servidor mock para desenvolvimento paralelo");
+    for (const r of risks)
+        out.push(r);
+    out.push("");
+    // Recommendation
+    out.push("## 9. Benchmark de Mercado");
+    out.push("");
+    // Gerar benchmark baseado no segmento detectado
+    const lower = idea.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    if (lower.includes("consignado") || lower.includes("credito") || lower.includes("emprestimo")) {
+        out.push("Comparativo com principais players do segmento de credito consignado:");
+        out.push("");
+        out.push("| Dimensao | Nosso Produto | BMG | Banco Pan | Mercantil | Crefisa | Nubank |");
+        out.push("| Tipo: | nosso | banco | banco | banco | financeira | fintech |");
+        out.push("| Taxa minima (% a.m.) | 1.49 | 1.80 | 1.75 | 1.83 | 2.20 | 1.69 |");
+        out.push("| Prazo maximo (meses) | 84 | 84 | 72 | 72 | 60 | 84 |");
+        out.push("| Contratacao 100% digital | Sim | Parcial | Parcial | Nao | Parcial | Sim |");
+        out.push("| Tempo de aprovacao (min) | 5 | 30 | 45 | 60 | 20 | 10 |");
+        out.push("| Simulacao no app | Sim | Sim | Nao | Nao | Nao | Sim |");
+        out.push("| Averbacao automatica | Sim | Nao | Nao | Nao | Nao | Parcial |");
+        out.push("| Portabilidade integrada | Sim | Nao | Parcial | Nao | Nao | Sim |");
+        out.push("| Margem em tempo real | Sim | Nao | Nao | Nao | Nao | Parcial |");
+        out.push("| Atendimento omnichannel | Sim | Parcial | Parcial | Nao | Parcial | Sim |");
+        out.push("");
+        out.push("**Fontes:**");
+        out.push("- BACEN — Ranking de Reclamacoes e Taxas de Juros por Instituicao (bcb.gov.br/ranking)");
+        out.push("- BACEN — Sistema de Informacoes de Credito (SCR) — Relatorio de Economia Bancaria 2025");
+        out.push("- FEBRABAN — Pesquisa de Tecnologia Bancaria 2025");
+        out.push("- Sites institucionais: bmg.com.br, bancopan.com.br, mercantildobrasil.com.br, crefisa.com.br, nubank.com.br");
+        out.push("- Reclame Aqui — Indice de satisfacao por instituicao (reclameaqui.com.br)");
+        out.push("- App Store / Google Play — Avaliacoes e funcionalidades dos apps concorrentes");
+        out.push("- INSS/Dataprev — Regras de margem consignavel e averbacao (gov.br/inss)");
+    }
+    else if (lower.includes("cartao") || lower.includes("card")) {
+        out.push("Comparativo com principais players do segmento de cartoes:");
+        out.push("");
+        out.push("| Dimensao | Nosso Produto | Nubank | C6 Bank | Inter | Itau | Bradesco |");
+        out.push("| Tipo: | nosso | fintech | fintech | banco | banco | banco |");
+        out.push("| Anuidade zero | Sim | Sim | Sim | Sim | Nao | Nao |");
+        out.push("| Cashback (%) | 1.5 | 1.0 | 0.5 | 0.8 | 0.0 | 0.0 |");
+        out.push("| Cartao virtual instantaneo | Sim | Sim | Sim | Sim | Parcial | Nao |");
+        out.push("| Limite flexivel | Sim | Sim | Parcial | Parcial | Nao | Nao |");
+        out.push("| Programa de pontos | Sim | Parcial | Sim | Parcial | Sim | Sim |");
+        out.push("");
+        out.push("**Fontes:**");
+        out.push("- BACEN — Ranking de Tarifas Bancarias (bcb.gov.br/ranking)");
+        out.push("- ABECS — Dados do mercado de cartoes 2025 (abecs.org.br)");
+        out.push("- Sites institucionais: nubank.com.br, c6bank.com.br, inter.co, itau.com.br, bradesco.com.br");
+        out.push("- App Store / Google Play — Avaliacoes e funcionalidades dos apps concorrentes");
+        out.push("- Reclame Aqui — Indice de satisfacao por instituicao (reclameaqui.com.br)");
+    }
+    else if (lower.includes("pix") || lower.includes("pagamento") || lower.includes("transferencia")) {
+        out.push("Comparativo com principais players do segmento de pagamentos:");
+        out.push("");
+        out.push("| Dimensao | Nosso Produto | Nubank | PicPay | Mercado Pago | Inter | C6 Bank |");
+        out.push("| Tipo: | nosso | fintech | fintech | fintech | banco | fintech |");
+        out.push("| Pix agendado | Sim | Sim | Sim | Sim | Sim | Sim |");
+        out.push("| Pix por aproximacao | Sim | Parcial | Nao | Nao | Nao | Nao |");
+        out.push("| QR Code dinamico | Sim | Sim | Sim | Sim | Parcial | Sim |");
+        out.push("| Cashback em Pix | Sim | Nao | Sim | Parcial | Nao | Nao |");
+        out.push("| Limite Pix personalizado | Sim | Sim | Parcial | Parcial | Sim | Sim |");
+        out.push("");
+        out.push("**Fontes:**");
+        out.push("- BACEN — Estatisticas do Pix (bcb.gov.br/estabilidadefinanceira/pix)");
+        out.push("- BACEN — Relatorio de Economia Bancaria 2025");
+        out.push("- Sites institucionais: nubank.com.br, picpay.com, mercadopago.com.br, inter.co, c6bank.com.br");
+        out.push("- App Store / Google Play — Avaliacoes e funcionalidades dos apps concorrentes");
+    }
+    else if (lower.includes("onboarding") || lower.includes("cadastro") || lower.includes("conta")) {
+        out.push("Comparativo com principais players do segmento de abertura de conta:");
+        out.push("");
+        out.push("| Dimensao | Nosso Produto | Nubank | Inter | C6 Bank | Itau | Original |");
+        out.push("| Tipo: | nosso | fintech | banco | fintech | banco | banco |");
+        out.push("| Abertura em minutos | 3 | 5 | 8 | 5 | 15 | 10 |");
+        out.push("| Selfie + documento | Sim | Sim | Sim | Sim | Sim | Sim |");
+        out.push("| Prova de vida automatica | Sim | Sim | Parcial | Parcial | Nao | Nao |");
+        out.push("| Conta ativa imediata | Sim | Sim | Sim | Sim | Nao | Parcial |");
+        out.push("| Integracao gov.br | Sim | Nao | Nao | Nao | Nao | Nao |");
+        out.push("");
+        out.push("**Fontes:**");
+        out.push("- BACEN — Ranking de Reclamacoes e Tarifas (bcb.gov.br/ranking)");
+        out.push("- FEBRABAN — Pesquisa de Tecnologia Bancaria 2025");
+        out.push("- Sites institucionais: nubank.com.br, inter.co, c6bank.com.br, itau.com.br, original.com.br");
+        out.push("- App Store / Google Play — Avaliacoes e funcionalidades dos apps concorrentes");
+        out.push("- gov.br — Portal de Servicos Digitais do Governo Federal");
+    }
+    else {
+        out.push("Segmento a ser definido apos detalhamento da ideia.");
+        out.push("O benchmark sera gerado com concorrentes especificos do segmento identificado.");
+    }
+    out.push("");
+    out.push("## 10. Recomendacao");
+    out.push("");
+    out.push("### Proximo Passo");
+    if (params.processId) {
+        out.push(`Este parecer faz parte do processo **${params.processId}**.`);
+        out.push("Avancar para a proxima fase do workflow:");
+        out.push("```");
+        out.push("Epicos (03) -> Estrategia (04/05) -> Execucao");
+        out.push("```");
+        out.push(`O stakeholder (01) e o intake/parecer (02) ja foram concluidos neste processo.`);
+    }
+    else {
+        out.push("Criar processo formal seguindo o workflow obrigatorio:");
+        out.push("```");
+        out.push("Stakeholder (01) -> Intake (02) -> Epicos (03) -> Estrategia (04/05) -> Execucao");
+        out.push("```");
+    }
+    out.push("");
+    out.push("### Estimativa Preliminar");
+    const complexity = detected.domains.size > 3 ? "alta" : detected.domains.size > 1 ? "media" : "baixa";
+    out.push(`- Complexidade: ${complexity} (${detected.domains.size} dominios impactados)`);
+    out.push(`- Squads envolvidas: ${affectedSquads.size + 2} (${affectedSquads.size} diretas + 2 transversais)`);
+    out.push(`- Integracoes novas estimadas: ${idea.toLowerCase().includes("inss") ? "2-3" : "1-2"}`);
+    return out.join("\n");
+}

package/dist/tools/validate-process.d.ts

@@ -0,0 +1,6 @@
+interface ValidateRequest {
+    processId: string;
+    artifacts: string[];
+}
+export declare function validateProcess(params: ValidateRequest): Promise<string>;
+export {};