@quantyapp/quanty-mcp-server 1.0.10 → 1.2.0

package/dist/mcp/index.js

@@ -7,11 +7,66 @@ import { initAuth } from '../core/auth.js';
 import * as budgetService from '../core/budgetService.js';
 import * as bankService from '../core/bankService.js';
 import * as analysisService from '../core/analysisService.js';
+import * as matchingService from '../core/matchingService.js';
+import { initLearningSystem, getLearningSystem, getContextBuilder } from '../core/learningService.js';
+// ================ GLOBAL STATE ================
+let learningSystem = null;
+let contextBuilder = null;
 // Pending operations for confirmation workflow
 const pendingOperations = new Map();
 function generatePendingId() {
     return `pending_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
+// ================ LEARNING WRAPPER ================
+/**
+ * Wraps tool execution with learning capabilities
+ */
+async function executeWithLearning(taskDescription, executionFn, extractSteps) {
+    const startTime = Date.now();
+    let result;
+    let success = false;
+    let steps = [];
+    try {
+        // Get relevant context from learning system
+        if (contextBuilder) {
+            try {
+                const context = await contextBuilder.buildContext(taskDescription);
+                if (context) {
+                    console.error(`[Learning] Applied context for: ${taskDescription}`);
+                    // Optionally inject context into global scope or similar if possible
+                    // For now, we mainly use it for system prompts or logging suggestions
+                }
+            }
+            catch (err) {
+                console.error(`[Learning] Failed to build context:`, err);
+            }
+        }
+        // Execute the actual function
+        result = await executionFn();
+        success = true;
+        // Extract steps if provided
+        if (extractSteps) {
+            try {
+                steps = extractSteps(result);
+            }
+            catch (err) {
+                console.error(`[Learning] Failed to extract steps:`, err);
+            }
+        }
+        // Learn from successful execution
+        if (learningSystem && success) {
+            const executionTime = Date.now() - startTime;
+            // Fire and forget learning to not block response
+            learningSystem.learnFromExecution(taskDescription, steps, result, executionTime).catch(err => console.error(`[Learning] Failed to store execution:`, err));
+            console.error(`[Learning] Stored execution: ${taskDescription} (${executionTime}ms)`);
+        }
+        return result;
+    }
+    catch (error) {
+        console.error(`[Learning] Execution failed: ${error}`);
+        throw error;
+    }
+}
 // ============================================================
 // MANUAL DO QUANTY - Este conteúdo é lido automaticamente pela IA
 // ============================================================
@@ -167,7 +222,8 @@ A importação traz automaticamente a unidade e custo do banco.`,
                 orcamento_id: { type: 'string', description: 'ID do orçamento destino' },
                 banco_item_id: { type: 'string', description: 'ID do item no banco (retornado por quanty_buscar_insumo)' },
                 banco_id: { type: 'string', description: 'ID do banco de origem' },
-                quantidade: { type: 'number', description: 'Quantidade a ser orçada' }
+                quantidade: { type: 'number', description: 'Quantidade a ser orçada' },
+                nivel: { type: 'number', description: 'Nível hierárquico/identação do item (0=raiz, 1=filho, 2=neto, etc). Padrão: 0' }
             },
             required: ['orcamento_id', 'banco_item_id', 'banco_id', 'quantidade']
         }
@@ -198,11 +254,61 @@ Retorna preview e pending_id. Use quanty_executar para confirmar.`,
                 descricao: { type: 'string', description: 'Descrição do item (ex: "Demolição manual de alvenaria")' },
                 unidade: { type: 'string', description: 'Unidade de medida (m², m³, m, kg, un, h, vb)' },
                 quantidade: { type: 'number', description: 'Quantidade do serviço' },
-                custo_unitario: { type: 'number', description: 'Custo unitário em R$ (sem BDI)' }
+                custo_unitario: { type: 'number', description: 'Custo unitário em R$ (sem BDI)' },
+                nivel: { type: 'number', description: 'Nível hierárquico/identação do item (0=raiz, 1=filho, 2=neto, etc). Padrão: 0' }
             },
             required: ['orcamento_id', 'descricao', 'unidade', 'quantidade', 'custo_unitario']
         }
     },
+    {
+        name: 'quanty_criar_composicao',
+        description: `Cria uma COMPOSIÇÃO (serviço composto) com seus INSUMOS do zero.
+Diferente de importar do banco, aqui você define todos os insumos manualmente.
+O custo unitário da composição é calculado automaticamente pela soma dos custos dos insumos.
+Retorna preview e pending_id. Use quanty_executar para confirmar.
+
+EXEMPLO de uso:
+{
+  "orcamento_id": "abc123",
+  "descricao": "Concretagem de pilar 20x40",
+  "unidade": "m³",
+  "quantidade": 15,
+  "insumos": [
+    {"descricao": "Concreto fck 30 MPa", "unidade": "m³", "quantidade": 1.05, "custo_unitario": 450.00},
+    {"descricao": "Forma de madeira", "unidade": "m²", "quantidade": 2.4, "custo_unitario": 85.00},
+    {"descricao": "Aço CA-50", "unidade": "kg", "quantidade": 120, "custo_unitario": 8.50},
+    {"descricao": "Pedreiro", "unidade": "h", "quantidade": 4, "custo_unitario": 25.00, "tipo": "MÃO DE OBRA"}
+  ]
+}`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento destino' },
+                codigo: { type: 'string', description: 'Código opcional da composição (ex: "COMP-001")' },
+                descricao: { type: 'string', description: 'Descrição da composição (ex: "Concretagem de pilar 20x40")' },
+                unidade: { type: 'string', description: 'Unidade de medida da composição (m², m³, m, un, vb)' },
+                quantidade: { type: 'number', description: 'Quantidade da composição no orçamento' },
+                nivel: { type: 'number', description: 'Nível hierárquico/identação (0=raiz, 1=filho, etc). Padrão: 0' },
+                insumos: {
+                    type: 'array',
+                    description: 'Lista de insumos que compõem o serviço',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            codigo: { type: 'string', description: 'Código opcional do insumo' },
+                            descricao: { type: 'string', description: 'Descrição do insumo' },
+                            unidade: { type: 'string', description: 'Unidade do insumo' },
+                            quantidade: { type: 'number', description: 'Coeficiente/quantidade do insumo por unidade da composição' },
+                            custo_unitario: { type: 'number', description: 'Custo unitário do insumo em R$' },
+                            tipo: { type: 'string', description: 'Tipo: INSUMO, MÃO DE OBRA, EQUIPAMENTO, etc. Padrão: INSUMO' }
+                        },
+                        required: ['descricao', 'unidade', 'quantidade', 'custo_unitario']
+                    }
+                }
+            },
+            required: ['orcamento_id', 'descricao', 'unidade', 'quantidade', 'insumos']
+        }
+    },
     {
         name: 'quanty_executar',
         description: `Confirma e executa uma operação pendente (criar orçamento, adicionar item, etc).
@@ -256,236 +362,1095 @@ Retorna média, mínimo, máximo e percentil 90 (para detecção de outliers).`,
             },
             required: ['driver']
         }
+    },
+    // === MANAGEMENT TOOLS ===
+    {
+        name: 'quanty_ajustar_bdi',
+        description: `Ajusta o BDI (Bonificações e Despesas Indiretas) do orçamento.
+O BDI é aplicado sobre o custo para calcular o preço de venda.
+Valor típico: 20% a 30%.
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                bdi_principal: { type: 'number', description: 'BDI Principal em % (ex: 25 para 25%)' },
+                bdi_diferenciado: { type: 'number', description: 'BDI Diferenciado em % (para equipamentos/materiais especiais)' }
+            },
+            required: ['orcamento_id']
+        }
+    },
+    {
+        name: 'quanty_editar_item',
+        description: `Edita um item EXISTENTE no orçamento.
+Permite alterar descrição, unidade, quantidade, custo unitário, nível e código.
+Use quanty_abrir_orcamento para obter os IDs dos itens.
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item a editar' },
+                descricao: { type: 'string', description: 'Nova descrição (opcional)' },
+                unidade: { type: 'string', description: 'Nova unidade (opcional)' },
+                quantidade: { type: 'number', description: 'Nova quantidade (opcional)' },
+                custo_unitario: { type: 'number', description: 'Novo custo unitário (opcional)' },
+                nivel: { type: 'number', description: 'Novo nível hierárquico (opcional)' },
+                codigo: { type: 'string', description: 'Novo código (opcional)' }
+            },
+            required: ['orcamento_id', 'item_id']
+        }
+    },
+    {
+        name: 'quanty_deletar_item',
+        description: `Deleta um item do orçamento.
+CUIDADO: Esta ação remove o item permanentemente.
+Use quanty_abrir_orcamento para obter os IDs e descrições dos itens.
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item a deletar' },
+                descricao_item: { type: 'string', description: 'Descrição do item (para confirmação visual)' }
+            },
+            required: ['orcamento_id', 'item_id', 'descricao_item']
+        }
+    },
+    {
+        name: 'quanty_duplicar_orcamento',
+        description: `Cria uma CÓPIA de um orçamento existente.
+Útil para criar variações ou versões de um orçamento.
+A cópia inclui todos os itens, BDI e configurações.
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento a duplicar' },
+                novo_titulo: { type: 'string', description: 'Título da cópia (ex: "Orçamento X - Versão 2")' }
+            },
+            required: ['orcamento_id', 'novo_titulo']
+        }
+    },
+    {
+        name: 'quanty_gerar_curva_abc',
+        description: `Gera análise CURVA ABC do orçamento.
+Classifica itens por impacto no custo total:
+- Classe A: ~20% dos itens que representam ~80% do custo (CRÍTICOS)
+- Classe B: ~30% dos itens que representam ~15% do custo (IMPORTANTES)
+- Classe C: ~50% dos itens que representam ~5% do custo (BAIXO IMPACTO)
+
+Útil para priorizar negociações e controle de custos.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento a analisar' },
+                limite_classe_a: { type: 'number', description: 'Percentual acumulado para Classe A (padrão: 80)' },
+                limite_classe_b: { type: 'number', description: 'Percentual acumulado para Classe B (padrão: 95)' }
+            },
+            required: ['orcamento_id']
+        }
+    },
+    {
+        name: 'quanty_mover_item',
+        description: `Altera o NÍVEL hierárquico de um item (identação).
+Níveis: 0 = raiz, 1 = filho, 2 = neto, etc.
+Use para organizar a estrutura do orçamento (EAP).
+Retorna preview e pending_id. Use quanty_executar para confirmar.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item a mover' },
+                novo_nivel: { type: 'number', description: 'Novo nível hierárquico (0, 1, 2, ...)' },
+                descricao_item: { type: 'string', description: 'Descrição do item (para confirmação visual)' }
+            },
+            required: ['orcamento_id', 'item_id', 'novo_nivel', 'descricao_item']
+        }
+    },
+    // === LEARNING TOOLS ===
+    {
+        name: 'quanty_aprender',
+        description: 'Ensina explicitamente uma nova capacidade ou procedimento ao sistema.\nO sistema armazenará esse conhecimento para uso futuro.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                capacidade: { type: 'string', description: 'Nome da capacidade' },
+                instrucoes: { type: 'string', description: 'Instruções detalhadas' }
+            },
+            required: ['capacidade', 'instrucoes']
+        }
+    },
+    {
+        name: 'quanty_feedback',
+        description: 'Fornece feedback sobre a última operação executada.\nAjuda o sistema a melhorar continuamente.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tipo: {
+                    type: 'string',
+                    description: 'Tipo de feedback',
+                    enum: ['success', 'failure', 'improvement']
+                },
+                detalhes: { type: 'string', description: 'Detalhes opcionais do feedback' }
+            },
+            required: ['tipo']
+        }
+    },
+    // === NEW TOOLS - EDIT BUDGET ===
+    {
+        name: 'quanty_editar_orcamento',
+        description: 'Edita metadados do orçamento: título, Data Base, BDI Principal e/ou BDI Diferenciado.\nPrepara a operação para confirmação.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                titulo: { type: 'string', description: 'Novo título do orçamento' },
+                data_base: { type: 'string', description: 'Data Base de preços (formato: MM/AAAA)' },
+                bdi_principal: { type: 'number', description: 'Novo BDI Principal (%)' },
+                bdi_diferenciado: { type: 'number', description: 'Novo BDI Diferenciado (%)' }
+            },
+            required: ['orcamento_id']
+        }
+    },
+    {
+        name: 'quanty_definir_bdi_item',
+        description: 'Define qual BDI um item usa: Principal ou Diferenciado.\nPrepara a operação para confirmação.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item' },
+                tipo_bdi: { type: 'string', enum: ['Principal', 'Diferenciado'], description: 'Tipo de BDI' },
+                descricao_item: { type: 'string', description: 'Descrição do item para confirmação' }
+            },
+            required: ['orcamento_id', 'item_id', 'tipo_bdi']
+        }
+    },
+    {
+        name: 'quanty_classificar_abc',
+        description: 'Define o tipo de recurso para classificação na Curva ABC.\nTipos: Custo, Material, Mão de Obra, Equipamento.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item' },
+                classificacao: { type: 'string', enum: ['Custo', 'Material', 'Mão de Obra', 'Equipamento'], description: 'Tipo de classificação ABC' },
+                descricao_item: { type: 'string', description: 'Descrição do item para confirmação' }
+            },
+            required: ['orcamento_id', 'item_id', 'classificacao']
+        }
+    },
+    // === NEW TOOLS - COMPOSITION EDITING ===
+    {
+        name: 'quanty_editar_insumo_composicao',
+        description: 'Edita um insumo dentro de uma composição existente.\nPode alterar código, descrição, unidade, quantidade ou custo unitário.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                composicao_id: { type: 'string', description: 'ID da composição' },
+                insumo_id: { type: 'string', description: 'ID do insumo a editar' },
+                codigo: { type: 'string', description: 'Novo código' },
+                descricao: { type: 'string', description: 'Nova descrição' },
+                unidade: { type: 'string', description: 'Nova unidade' },
+                quantidade: { type: 'number', description: 'Nova quantidade/coeficiente' },
+                custo_unitario: { type: 'number', description: 'Novo custo unitário' },
+                tipo_item: { type: 'string', description: 'Tipo do item (INSUMO, MATERIAL, MO, etc)' },
+                descricao_insumo: { type: 'string', description: 'Descrição do insumo para confirmação' }
+            },
+            required: ['orcamento_id', 'composicao_id', 'insumo_id']
+        }
+    },
+    {
+        name: 'quanty_adicionar_insumo_composicao',
+        description: 'Adiciona um novo insumo a uma composição existente.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                composicao_id: { type: 'string', description: 'ID da composição' },
+                codigo: { type: 'string', description: 'Código do insumo' },
+                descricao: { type: 'string', description: 'Descrição do insumo' },
+                unidade: { type: 'string', description: 'Unidade' },
+                quantidade: { type: 'number', description: 'Quantidade/coeficiente' },
+                custo_unitario: { type: 'number', description: 'Custo unitário' },
+                tipo_item: { type: 'string', description: 'Tipo do item (INSUMO, MATERIAL, MO, etc)' }
+            },
+            required: ['orcamento_id', 'composicao_id', 'descricao', 'unidade', 'quantidade', 'custo_unitario']
+        }
+    },
+    {
+        name: 'quanty_remover_insumo_composicao',
+        description: 'Remove um insumo de uma composição.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                composicao_id: { type: 'string', description: 'ID da composição' },
+                insumo_id: { type: 'string', description: 'ID do insumo a remover' },
+                descricao_insumo: { type: 'string', description: 'Descrição do insumo para confirmação' }
+            },
+            required: ['orcamento_id', 'composicao_id', 'insumo_id']
+        }
+    },
+    {
+        name: 'quanty_converter_para_composicao',
+        description: 'Converte um item de custo simples em composição.\nPermite depois adicionar insumos a ele.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item a converter' },
+                descricao_item: { type: 'string', description: 'Descrição do item para confirmação' }
+            },
+            required: ['orcamento_id', 'item_id']
+        }
+    },
+    {
+        name: 'quanty_converter_para_custo',
+        description: 'Converte uma composição de volta para custo simples.\nREMOVE todos os insumos da composição.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                orcamento_id: { type: 'string', description: 'ID do orçamento' },
+                item_id: { type: 'string', description: 'ID do item a converter' },
+                descricao_item: { type: 'string', description: 'Descrição do item para confirmação' }
+            },
+            required: ['orcamento_id', 'item_id']
+        }
+    },
+    // === NEW TOOLS - BANK MANAGEMENT ===
+    {
+        name: 'quanty_criar_banco',
+        description: 'Cria um banco de composições privado.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                nome: { type: 'string', description: 'Nome do banco' },
+                descricao: { type: 'string', description: 'Descrição do banco' }
+            },
+            required: ['nome']
+        }
+    },
+    {
+        name: 'quanty_editar_banco',
+        description: 'Edita metadados de um banco: título, descrição, imagem de capa, data da versão.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                banco_id: { type: 'string', description: 'ID do banco' },
+                titulo: { type: 'string', description: 'Novo título' },
+                descricao: { type: 'string', description: 'Nova descrição' },
+                imagem_capa: { type: 'string', description: 'URL da nova imagem de capa' },
+                data_versao: { type: 'string', description: 'Data da versão (formato: MM/AAAA)' }
+            },
+            required: ['banco_id']
+        }
+    },
+    {
+        name: 'quanty_adicionar_ao_banco',
+        description: 'Adiciona um item ou composição a um banco privado.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                banco_id: { type: 'string', description: 'ID do banco' },
+                categoria_id: { type: 'string', description: 'ID da categoria (ou novo ID para criar)' },
+                codigo: { type: 'string', description: 'Código do item' },
+                descricao: { type: 'string', description: 'Descrição do item' },
+                unidade: { type: 'string', description: 'Unidade' },
+                custo_unitario: { type: 'number', description: 'Custo unitário' },
+                tipo_item: { type: 'string', description: 'Tipo do item' },
+                eh_composicao: { type: 'boolean', description: 'Se é uma composição' },
+                insumos: { type: 'array', items: { type: 'object' }, description: 'Lista de insumos se for composição' }
+            },
+            required: ['banco_id', 'categoria_id', 'descricao', 'unidade', 'custo_unitario']
+        }
+    },
+    // === MATCHING TOOLS ===
+    {
+        name: 'quanty_buscar_similares',
+        description: 'Busca itens similares em outros orçamentos e bancos de composições.\nUsa normalização textual, sinônimos e múltiplas métricas de similaridade.\nIdeal para encontrar correspondências entre bases diferentes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                descricao: { type: 'string', description: 'Descrição do item a buscar' },
+                buscar_orcamentos: { type: 'boolean', description: 'Buscar em outros orçamentos (default: true)' },
+                buscar_bancos: { type: 'boolean', description: 'Buscar em bancos de composições (default: true)' },
+                excluir_orcamento_id: { type: 'string', description: 'ID do orçamento a excluir da busca' },
+                banco_ids: { type: 'array', items: { type: 'string' }, description: 'IDs de bancos específicos para buscar' },
+                limite: { type: 'number', description: 'Máximo de resultados (default: 10)' },
+                similaridade_minima: { type: 'number', description: 'Similaridade mínima % (default: 50)' }
+            },
+            required: ['descricao']
+        }
+    },
+    {
+        name: 'quanty_comparar_precos',
+        description: 'Compara o preço de um item com preços de itens similares encontrados em outros orçamentos e bancos.\nRetorna estatísticas (min, max, média, mediana) e recomendação.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                descricao: { type: 'string', description: 'Descrição do item' },
+                preco_atual: { type: 'number', description: 'Preço unitário atual do item' },
+                excluir_orcamento_id: { type: 'string', description: 'ID do orçamento a excluir da comparação' },
+                limite: { type: 'number', description: 'Máximo de itens para comparar (default: 20)' },
+                similaridade_minima: { type: 'number', description: 'Similaridade mínima % (default: 60)' }
+            },
+            required: ['descricao', 'preco_atual']
+        }
     }
 ];
 async function handleToolCall(auth, name, args) {
     switch (name) {
         // === DOCUMENTATION ===
         case 'quanty_ler_manual': {
-            return {
-                conteudo: QUANTY_MANUAL,
-                _info: 'Este manual contém tudo sobre BDI, Composições e estrutura do Quanty.'
-            };
+            return executeWithLearning('Ler manual do Quanty', async () => {
+                let content = QUANTY_MANUAL;
+                // Enrich with learning context
+                if (contextBuilder) {
+                    try {
+                        content = await contextBuilder.generateSystemPrompt(content);
+                    }
+                    catch (err) {
+                        console.error('Failed to generate system prompt:', err);
+                    }
+                }
+                return {
+                    conteudo: content,
+                    _info: 'Este manual contém tudo sobre BDI, Composições e estrutura do Quanty.'
+                };
+            });
         }
         // === READ ===
         case 'quanty_listar_orcamentos': {
-            const budgets = await budgetService.listBudgets(auth, args.limite || 10);
-            return {
-                _info: 'Use quanty_abrir_orcamento com o ID para ver detalhes completos',
-                total: budgets.length,
-                orcamentos: budgets.map(b => ({
-                    id: b.id,
-                    titulo: b.title,
-                    criado_em: b.createdAt,
-                    modificado_em: b.lastModified,
-                    criador: b.creator,
-                    compartilhado: b.shared,
-                    qtd_itens: b.itemCount,
-                    valor_total: `R$ ${b.totalValue.toFixed(2)}`
-                }))
-            };
+            return executeWithLearning(`Listar ${args.limite || 10} orçamentos recentes`, async () => {
+                const budgets = await budgetService.listBudgets(auth, args.limite || 10);
+                return {
+                    _info: 'Use quanty_abrir_orcamento com o ID para ver detalhes completos',
+                    total: budgets.length,
+                    orcamentos: budgets.map(b => ({
+                        id: b.id,
+                        titulo: b.title,
+                        criado_em: b.createdAt,
+                        modificado_em: b.lastModified,
+                        criador: b.creator,
+                        compartilhado: b.shared,
+                        qtd_itens: b.itemCount,
+                        valor_total: `R$ ${b.totalValue.toFixed(2)}`
+                    }))
+                };
+            });
         }
         case 'quanty_abrir_orcamento': {
-            const budget = await budgetService.getBudget(auth, args.id);
-            if (!budget)
-                return { erro: 'Orçamento não encontrado' };
-            const totalValue = budget.rows.reduce((sum, r) => sum + (r.quantity * r.unitCost), 0);
-            return {
-                id: budget.id,
-                titulo: budget.title,
-                bdi_principal: `${budget.bdiPrincipal}%`,
-                bdi_diferenciado: `${budget.bdiDiferenciado}%`,
-                valor_total: `R$ ${totalValue.toFixed(2)}`,
-                _info_itens: 'Itens com is_composicao=true são COMPOSIÇÕES que possuem insumos internos',
-                itens: budget.rows.map(r => ({
-                    id: r.id,
-                    nivel: r.level,
-                    codigo: r.code,
-                    descricao: r.description,
-                    unidade: r.unit,
-                    quantidade: r.quantity,
-                    custo_unitario: r.unitCost,
-                    total: r.quantity * r.unitCost,
-                    is_composicao: r.isComposition || false,
-                    bdi_tipo: r.bdiType || 'Principal'
-                }))
-            };
+            return executeWithLearning(`Abrir orçamento ${args.id}`, async () => {
+                const budget = await budgetService.getBudget(auth, args.id);
+                if (!budget)
+                    return { erro: 'Orçamento não encontrado' };
+                const totalValue = budget.rows.reduce((sum, r) => sum + (r.quantity * r.unitCost), 0);
+                return {
+                    id: budget.id,
+                    titulo: budget.title,
+                    bdi_principal: `${budget.bdiPrincipal}%`,
+                    bdi_diferenciado: `${budget.bdiDiferenciado}%`,
+                    valor_total: `R$ ${totalValue.toFixed(2)}`,
+                    _info_itens: 'Itens com is_composicao=true são COMPOSIÇÕES que possuem insumos internos',
+                    itens: budget.rows.map(r => ({
+                        id: r.id,
+                        nivel: r.level,
+                        codigo: r.code,
+                        descricao: r.description,
+                        unidade: r.unit,
+                        quantidade: r.quantity,
+                        custo_unitario: r.unitCost,
+                        total: r.quantity * r.unitCost,
+                        is_composicao: r.isComposition || false,
+                        bdi_tipo: r.bdiType || 'Principal'
+                    }))
+                };
+            });
         }
         case 'quanty_ver_composicao': {
-            const insumos = await budgetService.getCompositionDetails(auth, args.orcamento_id, args.item_id);
-            if (!insumos || insumos.length === 0) {
+            return executeWithLearning(`Ver composição ${args.item_id}`, async () => {
+                const insumos = await budgetService.getCompositionDetails(auth, args.orcamento_id, args.item_id);
+                if (!insumos || insumos.length === 0) {
+                    return {
+                        mensagem: 'Esta composição não possui insumos listados ou não é uma composição válida.'
+                    };
+                }
+                const totalComposicao = insumos.reduce((sum, i) => sum + (i.total || 0), 0);
                 return {
-                    mensagem: 'Esta composição não possui insumos listados ou não é uma composição válida.'
+                    _info: 'Lista de insumos/filhos desta composição',
+                    qtd_insumos: insumos.length,
+                    custo_total_calculado: `R$ ${totalComposicao.toFixed(2)}`,
+                    insumos: insumos.map(i => ({
+                        id: i.id, // ID necessário para recursão
+                        descricao: i.description,
+                        unidade: i.unit,
+                        coeficiente: i.quantity,
+                        custo_unitario_insumo: i.unitCost,
+                        custo_total_insumo: i.total,
+                        is_composicao: i.is_composicao, // Indica se pode descer mais um nível
+                        tipo: i.type
+                    }))
                 };
-            }
-            const totalComposicao = insumos.reduce((sum, i) => sum + i.total, 0);
-            return {
-                _info: 'Lista de insumos/filhos desta composição',
-                qtd_insumos: insumos.length,
-                custo_total_calculado: `R$ ${totalComposicao.toFixed(2)}`,
-                insumos: insumos.map(i => ({
-                    id: i.id, // ID necessário para recursão
-                    descricao: i.description,
-                    unidade: i.unit,
-                    coeficiente: i.quantity,
-                    custo_unitario_insumo: i.unitCost,
-                    custo_total_insumo: i.total,
-                    is_composicao: i.is_composicao, // Indica se pode descer mais um nível
-                    tipo: i.type
-                }))
-            };
+            });
         }
         case 'quanty_listar_bancos': {
-            const banks = await bankService.listBanks(auth);
-            return {
-                _info: 'Use quanty_buscar_insumo com o ID do banco para buscar itens',
-                total: banks.length,
-                bancos: banks.map(b => ({
-                    id: b.id,
-                    titulo: b.title,
-                    descricao: b.description,
-                    autor: b.author,
-                    regiao: b.region,
-                    visibilidade: b.visibility,
-                    qtd_categorias: b.categoryCount
-                }))
-            };
+            return executeWithLearning('Listar bancos', async () => {
+                const banks = await bankService.listBanks(auth);
+                return {
+                    _info: 'Use quanty_buscar_insumo com o ID do banco para buscar itens',
+                    total: banks.length,
+                    bancos: banks.map(b => ({
+                        id: b.id,
+                        titulo: b.title,
+                        descricao: b.description,
+                        autor: b.author,
+                        regiao: b.region,
+                        visibilidade: b.visibility,
+                        qtd_categorias: b.categoryCount
+                    }))
+                };
+            });
         }
         case 'quanty_buscar_insumo': {
-            const items = await bankService.searchBankItems(args.banco_id, args.busca);
-            return {
-                _info: 'Itens do tipo COMPOSIÇÃO possuem insumos internos que definem o custo',
-                total: items.length,
-                resultados: items.map(i => ({
-                    id: i.id,
-                    codigo: i.code,
-                    descricao: i.description,
-                    unidade: i.unit,
-                    custo_unitario: i.unitCost,
-                    tipo: i.itemType,
-                    is_composicao: i.isComposition,
-                    qtd_insumos: i.composition?.length || 0
-                }))
-            };
+            return executeWithLearning(`Buscar "${args.busca}" no banco`, async () => {
+                const items = await bankService.searchBankItems(args.banco_id, args.busca);
+                return {
+                    _info: 'Itens do tipo COMPOSIÇÃO possuem insumos internos que definem o custo',
+                    total: items.length,
+                    resultados: items.map(i => ({
+                        id: i.id,
+                        codigo: i.code,
+                        descricao: i.description,
+                        unidade: i.unit,
+                        custo_unitario: i.unitCost,
+                        tipo: i.itemType,
+                        is_composicao: i.isComposition,
+                        qtd_insumos: i.composition?.length || 0
+                    }))
+                };
+            });
         }
         // === WRITE (with confirmation) ===
         case 'quanty_importar_item': {
-            const item = await bankService.getBankItemById(args.banco_id, args.banco_item_id);
-            if (!item)
-                return { erro: 'Item não encontrado no banco de dados.' };
-            // Passa a quantidade diretamente para o preparador
-            const prepared = bankService.prepareImportItem(args.orcamento_id, item, args.quantidade);
-            const pendingId = generatePendingId();
-            pendingOperations.set(pendingId, {
-                action: prepared.action,
-                data: prepared.data,
-                expiresAt: Date.now() + 5 * 60 * 1000
+            return executeWithLearning(`Importar item ${args.banco_item_id}`, async () => {
+                const item = await bankService.getBankItemById(args.banco_id, args.banco_item_id);
+                if (!item)
+                    return { erro: 'Item não encontrado no banco de dados.' };
+                // Passa a quantidade e nivel diretamente para o preparador
+                const prepared = bankService.prepareImportItem(args.orcamento_id, item, args.quantidade, args.nivel);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    is_composicao: item.isComposition,
+                    qtd_insumos: item.composition?.length || 0,
+                    mensagem: 'Use quanty_executar para confirmar.'
+                };
             });
-            return {
-                pending_id: pendingId,
-                preview: prepared.preview,
-                is_composicao: item.isComposition,
-                qtd_insumos: item.composition?.length || 0,
-                mensagem: 'Use quanty_executar para confirmar.'
-            };
         }
         case 'quanty_preparar_orcamento': {
-            const prepared = budgetService.prepareCreateBudget(auth, args.titulo);
-            const pendingId = generatePendingId();
-            pendingOperations.set(pendingId, {
-                action: prepared.action,
-                data: prepared.data,
-                expiresAt: Date.now() + 5 * 60 * 1000
+            return executeWithLearning(`Preparar orçamento "${args.titulo}"`, async () => {
+                const prepared = budgetService.prepareCreateBudget(auth, args.titulo);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar a criação.'
+                };
             });
-            return {
-                pending_id: pendingId,
-                preview: prepared.preview,
-                mensagem: 'Use quanty_executar com este pending_id para confirmar a criação.'
-            };
         }
         case 'quanty_preparar_item': {
-            const prepared = budgetService.prepareAddItem(args.orcamento_id, {
-                description: args.descricao,
-                unit: args.unidade,
-                quantity: args.quantidade,
-                unitCost: args.custo_unitario
-            });
-            const pendingId = generatePendingId();
-            pendingOperations.set(pendingId, {
-                action: prepared.action,
-                data: prepared.data,
-                expiresAt: Date.now() + 5 * 60 * 1000
+            return executeWithLearning(`Preparar item "${args.descricao}"`, async () => {
+                const prepared = budgetService.prepareAddItem(args.orcamento_id, {
+                    description: args.descricao,
+                    unit: args.unidade,
+                    quantity: args.quantidade,
+                    unitCost: args.custo_unitario,
+                    level: args.nivel
+                });
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar a adição.'
+                };
+            });
+        }
+        case 'quanty_criar_composicao': {
+            return executeWithLearning(`Criar composição "${args.descricao}"`, async () => {
+                // Transforma os insumos do formato MCP para o formato interno
+                const insumos = (args.insumos || []).map((i) => ({
+                    code: i.codigo,
+                    description: i.descricao,
+                    unit: i.unidade,
+                    quantity: i.quantidade,
+                    unitCost: i.custo_unitario,
+                    itemType: i.tipo || 'INSUMO'
+                }));
+                const prepared = budgetService.prepareAddComposition(args.orcamento_id, {
+                    code: args.codigo,
+                    description: args.descricao,
+                    unit: args.unidade,
+                    quantity: args.quantidade,
+                    level: args.nivel,
+                    insumos
+                });
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                // Calcula o custo unitário para mostrar no preview
+                const custoUnitario = insumos.reduce((sum, i) => sum + (i.quantity * i.unitCost), 0);
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    custo_unitario_calculado: `R$ ${custoUnitario.toFixed(2)}`,
+                    qtd_insumos: insumos.length,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar a criação da composição.'
+                };
             });
-            return {
-                pending_id: pendingId,
-                preview: prepared.preview,
-                mensagem: 'Use quanty_executar com este pending_id para confirmar a adição.'
-            };
         }
         case 'quanty_executar': {
-            const pending = pendingOperations.get(args.pending_id);
-            if (!pending) {
-                return { erro: 'Operação pendente não encontrada ou expirada' };
-            }
-            if (Date.now() > pending.expiresAt) {
-                pendingOperations.delete(args.pending_id);
-                return { erro: 'Operação expirada. Prepare novamente.' };
-            }
-            pendingOperations.delete(args.pending_id);
-            switch (pending.action) {
-                case 'create_budget': {
-                    const budgetId = await budgetService.executeCreateBudget(auth, pending.data);
-                    return { sucesso: true, orcamento_id: budgetId, mensagem: 'Orçamento criado com sucesso!' };
+            return executeWithLearning(`Executar operação ${args.pending_id}`, async () => {
+                const pending = pendingOperations.get(args.pending_id);
+                if (!pending) {
+                    return { erro: 'Operação pendente não encontrada ou expirada' };
                 }
-                case 'add_item': {
-                    await budgetService.executeAddItem(auth, pending.data);
-                    return { sucesso: true, mensagem: 'Item adicionado com sucesso!' };
+                if (Date.now() > pending.expiresAt) {
+                    pendingOperations.delete(args.pending_id);
+                    return { erro: 'Operação expirada. Prepare novamente.' };
                 }
-                case 'import_item': {
-                    await budgetService.executeAddItem(auth, pending.data);
-                    return { sucesso: true, mensagem: 'Item importado com sucesso!' };
+                pendingOperations.delete(args.pending_id);
+                switch (pending.action) {
+                    case 'create_budget': {
+                        const budgetId = await budgetService.executeCreateBudget(auth, pending.data);
+                        return { sucesso: true, orcamento_id: budgetId, mensagem: 'Orçamento criado com sucesso!' };
+                    }
+                    case 'add_item': {
+                        await budgetService.executeAddItem(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Item adicionado com sucesso!' };
+                    }
+                    case 'import_item': {
+                        await budgetService.executeAddItem(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Item importado com sucesso!' };
+                    }
+                    case 'update_bdi': {
+                        await budgetService.executeUpdateBdi(auth, pending.data);
+                        return { sucesso: true, mensagem: 'BDI atualizado com sucesso!' };
+                    }
+                    case 'edit_item': {
+                        await budgetService.executeEditItem(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Item editado com sucesso!' };
+                    }
+                    case 'delete_item': {
+                        await budgetService.executeDeleteItem(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Item deletado com sucesso!' };
+                    }
+                    case 'duplicate_budget': {
+                        const newBudgetId = await budgetService.executeDuplicateBudget(auth, pending.data);
+                        return { sucesso: true, orcamento_id: newBudgetId, mensagem: 'Orçamento duplicado com sucesso!' };
+                    }
+                    case 'edit_budget': {
+                        await budgetService.executeEditBudget(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Orçamento editado com sucesso!' };
+                    }
+                    case 'set_abc_classification': {
+                        await budgetService.executeSetAbcClassification(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Classificação ABC atualizada com sucesso!' };
+                    }
+                    case 'edit_composition_input': {
+                        await budgetService.executeEditCompositionInput(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Insumo da composição editado com sucesso!' };
+                    }
+                    case 'add_composition_input': {
+                        await budgetService.executeAddCompositionInput(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Insumo adicionado à composição com sucesso!' };
+                    }
+                    case 'remove_composition_input': {
+                        await budgetService.executeRemoveCompositionInput(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Insumo removido da composição com sucesso!' };
+                    }
+                    case 'convert_to_composition': {
+                        await budgetService.executeConvertToComposition(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Item convertido para composição com sucesso! Agora você pode adicionar insumos.' };
+                    }
+                    case 'convert_to_cost': {
+                        await budgetService.executeConvertToCost(auth, pending.data);
+                        return { sucesso: true, mensagem: 'Composição convertida para custo simples com sucesso!' };
+                    }
+                    default:
+                        return { erro: `Ação desconhecida: ${pending.action}` };
                 }
-                default:
-                    return { erro: `Ação desconhecida: ${pending.action}` };
-            }
+            });
         }
         // === ANALYSIS ===
         case 'quanty_orcamentos_similares': {
-            const similar = await analysisService.findSimilarBudgets(auth, args.orcamento_id);
-            return {
-                total: similar.length,
-                similares: similar.map(s => ({
-                    id: s.id,
-                    titulo: s.title,
-                    similaridade: `${s.similarity}%`,
-                    itens_em_comum: s.commonItems
-                }))
-            };
+            return executeWithLearning(`Buscar orçamentos similares`, async () => {
+                const similar = await analysisService.findSimilarBudgets(auth, args.orcamento_id);
+                return {
+                    total: similar.length,
+                    similares: similar.map(s => ({
+                        id: s.id,
+                        titulo: s.title,
+                        similaridade: `${s.similarity}%`,
+                        itens_em_comum: s.commonItems
+                    }))
+                };
+            });
         }
         case 'quanty_sugerir_itens': {
-            const suggestions = await analysisService.suggestMissingItems(auth, args.orcamento_id);
+            return executeWithLearning(`Sugerir itens`, async () => {
+                const suggestions = await analysisService.suggestMissingItems(auth, args.orcamento_id);
+                return {
+                    total: suggestions.length,
+                    sugestoes: suggestions.map(s => ({
+                        descricao: s.description,
+                        unidade: s.unit,
+                        custo_medio: `R$ ${s.avgUnitCost.toFixed(2)}`,
+                        frequencia: s.frequency,
+                        razao: s.reason
+                    }))
+                };
+            });
+        }
+        case 'quanty_custo_medio': {
+            return executeWithLearning(`Calcular custo médio de ${args.driver}`, async () => {
+                const metric = await analysisService.calculateCostPerUnit(auth, args.categoria || '', args.driver);
+                return {
+                    driver: metric.driver,
+                    custo_medio: `R$ ${metric.avgCostPerUnit.toFixed(2)}`,
+                    custo_minimo: `R$ ${metric.minCost.toFixed(2)}`,
+                    custo_maximo: `R$ ${metric.maxCost.toFixed(2)}`,
+                    custo_p90: `R$ ${metric.p90Cost.toFixed(2)}`,
+                    amostra: `${metric.sampleSize} orçamentos analisados`
+                };
+            });
+        }
+        // === MANAGEMENT HANDLERS ===
+        case 'quanty_ajustar_bdi': {
+            return executeWithLearning(`Ajustar BDI`, async () => {
+                const prepared = budgetService.prepareUpdateBdi(args.orcamento_id, args.bdi_principal, args.bdi_diferenciado);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_editar_item': {
+            return executeWithLearning(`Editar item`, async () => {
+                const updates = {};
+                if (args.descricao !== undefined)
+                    updates.description = args.descricao;
+                if (args.unidade !== undefined)
+                    updates.unit = args.unidade;
+                if (args.quantidade !== undefined)
+                    updates.quantity = args.quantidade;
+                if (args.custo_unitario !== undefined)
+                    updates.unitCost = args.custo_unitario;
+                if (args.nivel !== undefined)
+                    updates.level = args.nivel;
+                if (args.codigo !== undefined)
+                    updates.code = args.codigo;
+                const prepared = budgetService.prepareEditItem(args.orcamento_id, args.item_id, updates);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_deletar_item': {
+            return executeWithLearning(`Deletar item`, async () => {
+                const prepared = budgetService.prepareDeleteItem(args.orcamento_id, args.item_id, args.descricao_item);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar a exclusão.'
+                };
+            });
+        }
+        case 'quanty_duplicar_orcamento': {
+            return executeWithLearning(`Duplicar orçamento`, async () => {
+                const prepared = budgetService.prepareDuplicateBudget(auth, args.orcamento_id, args.novo_titulo);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar a duplicação.'
+                };
+            });
+        }
+        case 'quanty_gerar_curva_abc': {
+            return executeWithLearning(`Gerar Curva ABC`, async () => {
+                const result = await analysisService.generateAbcCurve(auth, args.orcamento_id, args.limite_classe_a || 80, args.limite_classe_b || 95);
+                return {
+                    valor_total: `R$ ${result.totalValue.toFixed(2)}`,
+                    resumo: {
+                        classe_a: `${result.classACount} itens (${result.classAThreshold}% do valor)`,
+                        classe_b: `${result.classBCount} itens (${result.classBThreshold - result.classAThreshold}% do valor)`,
+                        classe_c: `${result.classCCount} itens (${100 - result.classBThreshold}% do valor)`
+                    },
+                    itens: result.items.map(item => ({
+                        id: item.id,
+                        descricao: item.description,
+                        total: `R$ ${item.total.toFixed(2)}`,
+                        percentual: `${item.percentage}%`,
+                        acumulado: `${item.accumulated}%`,
+                        classe: item.class
+                    }))
+                };
+            });
+        }
+        case 'quanty_mover_item': {
+            return executeWithLearning(`Mover item de nível`, async () => {
+                const prepared = budgetService.prepareMoveItem(args.orcamento_id, args.item_id, args.novo_nivel, args.descricao_item);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        // === LEARNING ===
+        case 'quanty_aprender': {
+            if (!learningSystem)
+                throw new Error('Sistema de aprendizado não inicializado');
+            await learningSystem.learnFromExecution(args.capacidade, [{ type: 'explicit_learning', instructions: args.instrucoes }], { success: true }, 0);
             return {
-                total: suggestions.length,
-                sugestoes: suggestions.map(s => ({
-                    descricao: s.description,
-                    unidade: s.unit,
-                    custo_medio: `R$ ${s.avgUnitCost.toFixed(2)}`,
-                    frequencia: s.frequency,
-                    razao: s.reason
-                }))
+                status: 'success',
+                message: `Aprendi sobre: ${args.capacidade}. Este conhecimento será aplicado em futuras operações.`
             };
         }
-        case 'quanty_custo_medio': {
-            const metric = await analysisService.calculateCostPerUnit(auth, args.categoria || '', args.driver);
+        case 'quanty_feedback': {
+            if (!learningSystem)
+                throw new Error('Sistema de aprendizado não inicializado');
+            await learningSystem.processFeedback('last_operation', // Simplified for now
+            args.tipo, args.detalhes);
+            console.error(`[Feedback] Type: ${args.tipo}, Details: ${args.detalhes || 'N/A'}`);
             return {
-                driver: metric.driver,
-                custo_medio: `R$ ${metric.avgCostPerUnit.toFixed(2)}`,
-                custo_minimo: `R$ ${metric.minCost.toFixed(2)}`,
-                custo_maximo: `R$ ${metric.maxCost.toFixed(2)}`,
-                custo_p90: `R$ ${metric.p90Cost.toFixed(2)}`,
-                amostra: `${metric.sampleSize} orçamentos analisados`
+                status: 'success',
+                message: 'Feedback registrado. Obrigado por ajudar a melhorar o sistema!'
             };
         }
+        // === NEW HANDLERS - EDIT BUDGET ===
+        case 'quanty_editar_orcamento': {
+            return executeWithLearning(`Editar orçamento`, async () => {
+                const updates = {};
+                if (args.titulo !== undefined)
+                    updates.title = args.titulo;
+                if (args.data_base !== undefined)
+                    updates.baseDate = args.data_base;
+                if (args.bdi_principal !== undefined)
+                    updates.bdiPrincipal = args.bdi_principal;
+                if (args.bdi_diferenciado !== undefined)
+                    updates.bdiDiferenciado = args.bdi_diferenciado;
+                const prepared = budgetService.prepareEditBudget(args.orcamento_id, updates);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_definir_bdi_item': {
+            return executeWithLearning(`Definir BDI de item`, async () => {
+                const prepared = budgetService.prepareSetBdiType(args.orcamento_id, args.item_id, args.tipo_bdi, args.descricao_item || 'Item');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_classificar_abc': {
+            return executeWithLearning(`Classificar ABC`, async () => {
+                const prepared = budgetService.prepareSetAbcClassification(args.orcamento_id, args.item_id, args.classificacao, args.descricao_item || 'Item');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        // === NEW HANDLERS - COMPOSITION EDITING ===
+        case 'quanty_editar_insumo_composicao': {
+            return executeWithLearning(`Editar insumo de composição`, async () => {
+                const updates = {};
+                if (args.codigo !== undefined)
+                    updates.code = args.codigo;
+                if (args.descricao !== undefined)
+                    updates.description = args.descricao;
+                if (args.unidade !== undefined)
+                    updates.unit = args.unidade;
+                if (args.quantidade !== undefined)
+                    updates.quantity = args.quantidade;
+                if (args.custo_unitario !== undefined)
+                    updates.unitCost = args.custo_unitario;
+                if (args.tipo_item !== undefined)
+                    updates.itemType = args.tipo_item;
+                const prepared = budgetService.prepareEditCompositionInput(args.orcamento_id, args.composicao_id, args.insumo_id, updates, args.descricao_insumo || 'Insumo');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_adicionar_insumo_composicao': {
+            return executeWithLearning(`Adicionar insumo a composição`, async () => {
+                const input = {
+                    code: args.codigo || '',
+                    description: args.descricao,
+                    unit: args.unidade,
+                    quantity: args.quantidade,
+                    unitCost: args.custo_unitario,
+                    itemType: args.tipo_item || 'INSUMO'
+                };
+                const prepared = budgetService.prepareAddCompositionInput(args.orcamento_id, args.composicao_id, input);
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_remover_insumo_composicao': {
+            return executeWithLearning(`Remover insumo de composição`, async () => {
+                const prepared = budgetService.prepareRemoveCompositionInput(args.orcamento_id, args.composicao_id, args.insumo_id, args.descricao_insumo || 'Insumo');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_converter_para_composicao': {
+            return executeWithLearning(`Converter para composição`, async () => {
+                const prepared = budgetService.prepareConvertToComposition(args.orcamento_id, args.item_id, args.descricao_item || 'Item');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        case 'quanty_converter_para_custo': {
+            return executeWithLearning(`Converter para custo`, async () => {
+                const prepared = budgetService.prepareConvertToCost(args.orcamento_id, args.item_id, args.descricao_item || 'Item');
+                const pendingId = generatePendingId();
+                pendingOperations.set(pendingId, {
+                    action: prepared.action,
+                    data: prepared.data,
+                    expiresAt: Date.now() + 5 * 60 * 1000
+                });
+                return {
+                    pending_id: pendingId,
+                    preview: prepared.preview,
+                    mensagem: 'Use quanty_executar com este pending_id para confirmar.'
+                };
+            });
+        }
+        // === NEW HANDLERS - BANK MANAGEMENT ===
+        case 'quanty_criar_banco': {
+            return executeWithLearning(`Criar banco privado`, async () => {
+                const bankId = await bankService.createPrivateBank(auth, args.nome, args.descricao);
+                return {
+                    sucesso: true,
+                    banco_id: bankId,
+                    mensagem: `Banco "${args.nome}" criado com sucesso!`
+                };
+            });
+        }
+        case 'quanty_editar_banco': {
+            return executeWithLearning(`Editar banco`, async () => {
+                const updates = {};
+                if (args.titulo !== undefined)
+                    updates.title = args.titulo;
+                if (args.descricao !== undefined)
+                    updates.description = args.descricao;
+                if (args.imagem_capa !== undefined)
+                    updates.background_image = args.imagem_capa;
+                if (args.data_versao !== undefined)
+                    updates.versionDate = args.data_versao;
+                await bankService.editBank(auth, args.banco_id, updates);
+                return {
+                    sucesso: true,
+                    mensagem: 'Banco atualizado com sucesso!'
+                };
+            });
+        }
+        case 'quanty_adicionar_ao_banco': {
+            return executeWithLearning(`Adicionar item ao banco`, async () => {
+                const item = {
+                    code: args.codigo || '',
+                    description: args.descricao,
+                    unit: args.unidade,
+                    unitCost: args.custo_unitario,
+                    itemType: args.tipo_item || 'Insumo',
+                    isComposition: args.eh_composicao || false,
+                    composition: args.insumos || []
+                };
+                const result = await bankService.addItemToBank(auth, args.banco_id, args.categoria_id, item);
+                return {
+                    sucesso: true,
+                    mensagem: result
+                };
+            });
+        }
+        // === MATCHING HANDLERS ===
+        case 'quanty_buscar_similares': {
+            return executeWithLearning(`Buscar itens similares: ${args.descricao.substring(0, 50)}...`, async () => {
+                const results = await matchingService.findSimilarItems(auth, args.descricao, {
+                    searchBudgets: args.buscar_orcamentos !== false,
+                    searchBanks: args.buscar_bancos !== false,
+                    excludeBudgetId: args.excluir_orcamento_id,
+                    bankIds: args.banco_ids,
+                    limit: args.limite || 10,
+                    minSimilarity: args.similaridade_minima || 50
+                });
+                return {
+                    descricao_buscada: args.descricao,
+                    total_orcamentos: results.budgetResults.length,
+                    total_bancos: results.bankResults.length,
+                    melhores_correspondencias: results.topMatches.map(m => ({
+                        codigo: m.code,
+                        descricao: m.description,
+                        unidade: m.unit,
+                        custo_unitario: `R$ ${m.unitCost.toFixed(2)}`,
+                        fonte: m.source === 'budget' ? 'Orçamento' : 'Banco',
+                        fonte_nome: m.sourceName,
+                        similaridade: `${m.similarity}%`,
+                        detalhes: {
+                            fuzzy: `${m.similarityDetails.fuzzy}%`,
+                            palavras_chave: `${m.similarityDetails.keyword}%`,
+                            tfidf: `${m.similarityDetails.tfidf}%`
+                        }
+                    })),
+                    _info: 'Similaridade combina análise fuzzy, palavras-chave e TF-IDF. Itens com >70% são boas correspondências.'
+                };
+            });
+        }
+        case 'quanty_comparar_precos': {
+            return executeWithLearning(`Comparar preços: ${args.descricao.substring(0, 50)}...`, async () => {
+                const comparison = await matchingService.comparePrices(auth, args.descricao, args.preco_atual, {
+                    excludeBudgetId: args.excluir_orcamento_id,
+                    limit: args.limite || 20,
+                    minSimilarity: args.similaridade_minima || 60
+                });
+                return {
+                    descricao: args.descricao,
+                    preco_atual: `R$ ${comparison.currentPrice.toFixed(2)}`,
+                    itens_comparados: comparison.matches.length,
+                    estatisticas: {
+                        preco_minimo: `R$ ${comparison.statistics.minPrice.toFixed(2)}`,
+                        preco_maximo: `R$ ${comparison.statistics.maxPrice.toFixed(2)}`,
+                        preco_medio: `R$ ${comparison.statistics.avgPrice.toFixed(2)}`,
+                        preco_mediano: `R$ ${comparison.statistics.medianPrice.toFixed(2)}`,
+                        recomendacao: comparison.statistics.recommendation
+                    },
+                    comparacoes: comparison.matches.slice(0, 10).map(m => ({
+                        descricao: m.description,
+                        unidade: m.unit,
+                        preco: `R$ ${m.unitCost.toFixed(2)}`,
+                        diferenca: `${m.priceDiffPercent >= 0 ? '+' : ''}${m.priceDiffPercent}%`,
+                        fonte: m.sourceName,
+                        similaridade: `${m.similarity}%`
+                    }))
+                };
+            });
+        }
         default:
             return { erro: `Tool não reconhecida: ${name}` };
     }
@@ -497,13 +1462,18 @@ async function main() {
     try {
         auth = await initAuth();
         console.error(`[Quanty MCP] Authenticated as ${auth.userName} (${auth.userEmail})`);
+        // Initialize Learning System
+        initLearningSystem(auth);
+        learningSystem = getLearningSystem();
+        contextBuilder = getContextBuilder();
+        console.error('[Quanty MCP] Learning System initialized');
     }
     catch (error) {
         console.error('[Quanty MCP] Auth failed:', error);
         process.exit(1);
     }
     // Create MCP server with resources capability
-    const server = new Server({ name: 'quanty-mcp-server', version: '1.0.0' }, { capabilities: { tools: {}, resources: {} } });
+    const server = new Server({ name: 'quanty-mcp-server', version: '2.0.0' }, { capabilities: { tools: {}, resources: {} } });
     // List resources handler - Manual do Quanty
     server.setRequestHandler(ListResourcesRequestSchema, async () => ({
         resources: [
@@ -512,14 +1482,35 @@ async function main() {
                 name: 'Manual do Quanty',
                 description: 'Documentação completa sobre orçamentação de engenharia, conceitos, terminologia e dicas de uso.',
                 mimeType: 'text/plain'
+            },
+            {
+                uri: 'quanty://learning-stats',
+                name: 'Estatísticas de Aprendizado',
+                description: 'Métricas sobre o aprendizado do sistema, padrões identificados e eficiência.',
+                mimeType: 'application/json'
             }
         ]
     }));
     // Read resource handler
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         if (request.params.uri === 'quanty://manual') {
+            let content = QUANTY_MANUAL;
+            if (contextBuilder) {
+                try {
+                    content = await contextBuilder.generateSystemPrompt(content);
+                }
+                catch (err) {
+                    console.error('Failed to enhance manual:', err);
+                }
+            }
+            return {
+                contents: [{ uri: 'quanty://manual', mimeType: 'text/plain', text: content }]
+            };
+        }
+        if (request.params.uri === 'quanty://learning-stats') {
+            const stats = learningSystem ? await learningSystem.getStatistics() : {};
             return {
-                contents: [{ uri: 'quanty://manual', mimeType: 'text/plain', text: QUANTY_MANUAL }]
+                contents: [{ uri: 'quanty://learning-stats', mimeType: 'application/json', text: JSON.stringify(stats, null, 2) }]
             };
         }
         throw new Error(`Resource not found: ${request.params.uri}`);