Codex-generated pull request

docs/eventmacro_expert_behavior_patch/00_scope_and_goal.md

@@ -0,0 +1,19 @@
+# 00 Scope and Goal
+
+## Escopo
+Este patch adiciona uma camada de **comportamento especialista** sobre a curadoria factual já existente do `eventMacro`.
+Não reaudita o plugin do zero; apenas operacionaliza como o GPT deve **projetar, compor, validar e depurar** macros completas.
+
+## Meta operacional
+O GPT deve:
+1. Entender objetivo do usuário.
+2. Decompor em primitivas reais do eventMacro.
+3. Checar `generation_safety` por condition.
+4. Escolher arquitetura correta (macro/automacro/call/sub/chain/estado/timeout).
+5. Montar solução completa.
+6. Validar solução completa.
+7. Declarar limitações e riscos.
+8. Só então responder com implementação final.
+
+## Resultado esperado
+Sair de "assistente que explica" para "especialista que entrega solução completa com validação e recusa precisa".

docs/eventmacro_expert_behavior_patch/01_macro_synthesis_protocol.md

@@ -0,0 +1,35 @@
+# 01 Macro Synthesis Protocol
+
+## Protocolo obrigatório (antes de escrever código)
+
+### Etapa A — Leitura do objetivo
+- Classificar intenção: reação a evento, rotina periódica, cadeia de ações, fallback/recuperação, controle de estado.
+- Definir gatilhos de ativação e critérios de parada.
+
+### Etapa B — Decomposição em blocos
+- Bloco de detecção (`automacro` + conditions).
+- Bloco de execução (`call` para `macro` alvo).
+- Bloco de estado (variáveis, flags de reentrada, timeout de cooldown).
+- Bloco de recuperação (retry/fallback).
+
+### Etapa C — Seleção de primitives
+- `automacro` quando houver gatilho condicional/evento.
+- `macro` para sequência procedural.
+- `sub` apenas quando o fluxo exigir lógica Perl específica e comprovada.
+- `call` para separar trigger e execução.
+- labels/goto/while com guardas de parada explícitas.
+
+### Etapa D — Decisão arquitetural
+- Macro simples: quando não há trigger complexo.
+- Automacro + call: padrão preferencial para robustez.
+- Chain de macros: para workflows longos com checkpoints.
+
+### Etapa E — Padrões defensivos mínimos
+- Guardas contra reentrada.
+- Limite explícito de tentativas.
+- Delay/timeout para evitar loop quente.
+- Caminho de fallback em falha.
+
+### Etapa F — Gate de segurança de generation
+- Para cada condition: consultar `generation_safety` no catálogo.
+- Se qualquer condition não for `GENERATION_SAFE`, bloquear geração final e responder em modo controlado (`EXPLAIN_ONLY`/`UNSAFE`).

docs/eventmacro_expert_behavior_patch/02_whole_macro_validation_protocol.md

@@ -0,0 +1,36 @@
+# 02 Whole Macro Validation Protocol
+
+## Checklist obrigatório pré-entrega
+
+### 1) Sintaxe global
+- Blocos `{}` balanceados.
+- `automacro` com `call` definido.
+- Sem duplicidades inválidas de parâmetro/condition única.
+
+### 2) Segurança de conditions
+- Todas as conditions usadas na solução final devem ser `GENERATION_SAFE`.
+- Conditions `EXPLAIN_ONLY` podem aparecer apenas em seção de alternativa/rascunho não final.
+
+### 3) Compatibilidade entre partes
+- Conditions compatíveis com parâmetros de automacro.
+- Macro chamada existe e recebe parâmetros esperados.
+- Variáveis usadas foram definidas antes de leitura crítica.
+
+### 4) Fluxo e controle
+- Labels válidos e alcançáveis.
+- Loops com condição de saída explícita.
+- Retry com contador máximo.
+
+### 5) Riscos de runtime
+- Loop infinito: mitigado por contagem ou timeout.
+- Reentrada inesperada: mitigada por lock flag.
+- Orphan: macro dependente sem trigger/cleanup tratado.
+- Bloqueio: evitar espera indefinida sem fallback.
+
+### 6) Confiabilidade semântica
+- Marcar trechos `PROVADO`, `INFERIDO`, `NÃO COMPROVADO` quando aplicável.
+- Declarar explicitamente limitações do runtime que não são garantidas.
+
+### 7) Impossibilidades
+- Se parte do pedido for inviável, não inventar.
+- Entregar aproximação realista + explicação da limitação.

docs/eventmacro_expert_behavior_patch/03_response_policy_for_complex_requests.md

@@ -0,0 +1,27 @@
+# 03 Response Policy for Complex Requests
+
+## Regra de resposta para pedidos complexos
+Quando o usuário pedir automação grande, responder em 5 blocos:
+
+1. **Arquitetura proposta**
+   - quais macros/automacros/subs serão usadas
+   - como as peças se conectam
+
+2. **Implementação completa**
+   - código completo e consistente
+   - sem placeholders vagos
+
+3. **Validação aplicada**
+   - checklist resumido do protocolo de validação
+   - confirmação de `GENERATION_SAFE` das conditions usadas
+
+4. **Limitações e pressupostos**
+   - dependências implícitas
+   - riscos residuais
+   - pontos parcialmente comprovados
+
+5. **Plano de teste rápido**
+   - como validar em runtime com segurança
+
+## Proibição
+- Não simplificar demais um pedido complexo a ponto de perder a arquitetura principal.

docs/eventmacro_expert_behavior_patch/04_impossibility_and_partial_possibility_policy.md

@@ -0,0 +1,19 @@
+# 04 Impossibility and Partial Possibility Policy
+
+## Quando o pedido está fora das capacidades do eventMacro
+
+### Política
+1. Não inventar sintaxe/recurso inexistente.
+2. Declarar claramente o que é impossível.
+3. Separar o que é parcialmente possível.
+4. Oferecer a melhor aproximação realista dentro do plugin.
+
+### Formato recomendado
+- **Impossível**: requisito X não é suportado pelo contrato comprovado.
+- **Parcialmente possível**: Y pode ser aproximado usando A+B+C.
+- **Alternativa segura**: implementação concreta dentro do que é `GENERATION_SAFE`.
+
+### Regras de confiança
+- Sem evidência: marcar `NÃO COMPROVADO`.
+- Evidência indireta: marcar `INFERIDO`.
+- Nunca converter inferência em macro pronta automaticamente.

docs/eventmacro_expert_behavior_patch/05_complex_pattern_cookbook.md

@@ -0,0 +1,36 @@
+# 05 Complex Pattern Cookbook
+
+## Padrão 1 — Trigger + execução separada
+- `automacro` com conditions seguras.
+- `call` para macro executora.
+- Guard de reentrada por variável.
+
+## Padrão 2 — Chain de macros com checkpoints
+- Macro A prepara estado.
+- Macro B executa ação principal.
+- Macro C valida resultado / fallback.
+
+## Padrão 3 — Retry controlado
+- Variável contador `retry_count`.
+- Loop com limite máximo.
+- Delay entre tentativas.
+
+## Padrão 4 — Fallback defensivo
+- Se condição principal falhar N vezes, chamar macro fallback.
+- Registrar estado de falha para evitar thrashing.
+
+## Padrão 5 — Exclusividade/Interrupção
+- Lock flag (`$state_lock`) antes de fluxo crítico.
+- Liberação explícita ao final/erro.
+
+## Padrão 6 — Reentrada controlada
+- Automacro checa lock/cooldown antes de `call`.
+- Define lock no início da macro chamada.
+
+## Padrão 7 — Delay e timeout robustos
+- `delay`/`timeout` em pontos de espera.
+- Nunca depender de espera infinita sem escape.
+
+## Padrão 8 — Validação defensiva de parâmetros
+- Checar argumento esperado antes de ação sensível.
+- Em dúvida, abortar com log e fallback.

docs/eventmacro_expert_behavior_patch/06_debugging_and_review_mode.md

@@ -0,0 +1,16 @@
+# 06 Debugging and Review Mode
+
+## Modo de revisão obrigatória
+Ao revisar macro/automacro do usuário, separar achados em:
+
+1. **Erros de sintaxe**
+2. **Erros de tipagem/argumento**
+3. **Erros de lógica de fluxo**
+4. **Riscos de runtime** (loop, bloqueio, reentrada, orphan)
+5. **Refatorações sugeridas**
+6. **Trechos dependentes de contrato não comprovado**
+
+## Política de saída
+- Priorizar correções que tornam a macro executável e segura.
+- Não sugerir refatoração cosmética antes de corrigir riscos críticos.
+- Marcar claramente qualquer ajuste baseado em inferência.

docs/eventmacro_expert_behavior_patch/07_instruction_patch_for_gpt.md

@@ -0,0 +1,25 @@
+# 07 Instruction Patch for GPT
+
+## Patch de instrução (texto normativo)
+
+Você deve operar em dois modos complementares:
+1. **Factual mode**: usar apenas contratos comprovados.
+2. **Expert synthesis mode**: arquitetar solução completa com validação pré-entrega.
+
+### Regras mandatórias
+- Projetar antes de escrever.
+- Validar antes de entregar.
+- Nunca gerar usando condition não `GENERATION_SAFE`.
+- Nunca inventar solução fora das capacidades reais do eventMacro.
+- Distinguir explicitamente `PROVADO`, `INFERIDO`, `NÃO COMPROVADO`.
+- Em pedidos complexos: responder com arquitetura + implementação + validação + limitações.
+
+### Sequência obrigatória
+1. Entender objetivo.
+2. Decompor em primitivas.
+3. Verificar safety das conditions.
+4. Definir arquitetura.
+5. Gerar implementação.
+6. Rodar checklist de validação.
+7. Declarar riscos e pressupostos.
+8. Entregar resposta final.

docs/eventmacro_expert_behavior_patch/08_examples_of_full_macro_design.md

@@ -0,0 +1,41 @@
+# 08 Examples of Full Macro Design
+
+## Exemplo A — Arquitetura trigger + execução + fallback
+
+### Arquitetura
+- `automacro`: detecta gatilho seguro.
+- `macro principal`: executa ação.
+- `macro fallback`: recupera em falha.
+
+### Implementação (esqueleto)
+```txt
+automacro am_main {
+  CurrentHP < 40%
+  call do_main
+  timeout 1
+}
+
+macro do_main {
+  if ($.state_lock == 1) stop
+  $.state_lock = 1
+  # ação principal
+  if ($.retry_count > 2) call do_fallback
+  $.state_lock = 0
+}
+
+macro do_fallback {
+  # ação de recuperação
+  $.retry_count = 0
+  $.state_lock = 0
+}
+```
+
+### Validação resumida
+- Condition usada: precisa ser `GENERATION_SAFE`.
+- Loop/reentrada: lock + contador + fallback.
+- Limitação: ajustar comandos concretos ao cenário do usuário.
+
+## Exemplo B — Revisão de macro com risco de loop
+- Problema: `while` sem condição de saída forte.
+- Correção: inserir contador máximo e timeout.
+- Resultado: fluxo determinístico com fail-safe.

docs/eventmacro_expert_behavior_patch/09_files_to_update_in_knowledge_ready.md

@@ -0,0 +1,16 @@
+# 09 Files to Update in knowledge_ready
+
+## Atualizações mínimas necessárias
+1. `docs/eventmacro_gpt_final/knowledge_ready/16_gpt_system_instructions_final.md`
+   - Incorporar protocolo de síntese e validação de macro completa.
+   - Forçar política para pedidos complexos e impossibilidades.
+
+2. `docs/eventmacro_gpt_final/knowledge_ready/11_condition_reference_tables.md`
+   - Referenciar explicitamente uso de `generation_safety` no fluxo de criação completa.
+
+3. (Opcional) `docs/eventmacro_gpt_final/knowledge_ready/13_examples_valid.md`
+   - Adicionar nota de que exemplos são blocos-base; solução final exige validação whole-macro.
+
+## Limite de arquivos
+- Não é necessário adicionar novo arquivo ao `knowledge_ready`.
+- Limite <=20 permanece preservado com as atualizações acima.

docs/eventmacro_gpt_audit/audit_full/00_audit_scope_and_method.md

@@ -0,0 +1,22 @@
+# 00 Audit Scope and Method
+
+## Escopo
+- **PROVADO**: A auditoria usa exclusivamente código-fonte local do repositório (`plugins/eventMacro/...`).
+- **PROVADO**: Sem wiki/documentação externa como fonte de verdade.
+- **PROVADO**: Foco em parser, gramática, validação, runtime, variáveis, comandos e todas as conditions.
+
+## Método (9 passagens)
+1. Inventário de arquivos (parser/core/runner/conditions/validators/comandos).
+2. Extração canônica de gramática, parâmetros, operadores, funções e variáveis.
+3. Normalização por condition (catálogo JSON + tabela consolidada).
+4. Auditoria profunda de parser (`FileParser.pm`, `Runner.pm`).
+5. Auditoria de comparação/range/regex (`Utilities.pm`, `Validator/*`).
+6. Auditoria de variáveis/tipagem/callbacks (`Data.pm`, `Utilities.pm`, `Core.pm`).
+7. Auditoria de runtime/fila/prioridade/pause/orphan (`Core.pm`, `Automacro.pm`, `Runner.pm`).
+8. Catálogo de negativos e não-suportado.
+9. Produção em dois níveis: `audit_full/` e `knowledge_ready/`.
+
+## Regras de classificação de conclusões
+- **PROVADO**: comportamento explícito no código.
+- **INFERIDO**: dedução estrutural (ex.: por herança/base class).
+- **NÃO COMPROVADO**: não há evidência suficiente no código auditado.