oxe-cc 1.11.0 → 1.14.0

package/oxe/workflows/route.md

@@ -13,15 +13,17 @@ Este passo é **meta**: só orientação. A execução real pertence ao workflow
 </context>
 
 <process>
-1. Ler a secção **Router** em `oxe/workflows/help.md` (ou `.oxe/workflows/help.md` no projeto).
-2. Classificar a intenção do utilizador e escolher **uma** linha da tabela.
-3. Se a classificação não for claramente dominante, ainda devolver um único destino, mas explicitar a confiança da escolha e a lacuna que poderia mudar o roteamento.
-4. Responder apenas:
+1. Verificar se o input é um **objetivo de implementação** (cria, implementa, adiciona, corrige, constrói, desenvolve, migra — verbos de ação sobre o código):
+   - **Sim** → destino direto: `oxe/workflows/conduct.md` (Conductor decide Agent Mode vs Swarm Mode). Não consultar tabela.
+2. Caso contrário, ler a secção **Router** em `oxe/workflows/help.md` (ou `.oxe/workflows/help.md` no projeto).
+3. Classificar a intenção do utilizador e escolher **uma** linha da tabela.
+4. Se a classificação não for claramente dominante, ainda devolver um único destino, mas explicitar a confiança da escolha e a lacuna que poderia mudar o roteamento.
+5. Responder apenas:
    - **Comando:** …
    - **Workflow:** `oxe/workflows/<nome>.md`
    - **Por quê:** (uma frase)
    - **Confiança:** alta | média | baixa (só quando houver ambiguidade real)
-5. Não criar ficheiros em `.oxe/` salvo o utilizador pedir explícito registo; se o utilizador pedir rastreio: acrescentar uma linha em **`.oxe/STATE.md`** (ex.: `last_route: /oxe-scan — YYYY-MM-DD`).
+6. Não criar ficheiros em `.oxe/` salvo o utilizador pedir explícito registo; se o utilizador pedir rastreio: acrescentar uma linha em **`.oxe/STATE.md`** (ex.: `last_route: /oxe-scan — YYYY-MM-DD`).
 </process>
 
 <success_criteria>

package/oxe/workflows/swarm/board.md

@@ -0,0 +1,119 @@
+# OXE — Workflow: swarm/board (Board Manager)
+
+<objective>
+Gerenciar o BOARD.md e BOARD.json do Swarm Run — a visão em tempo real do estado de cada tarefa,
+agente, bloqueio e wave. Consultado por qualquer agente do swarm para saber o que está acontecendo
+e atualizado após cada mudança de estado.
+</objective>
+
+<context>
+- Usado internamente por `swarm-mode.md` após cada fase.
+- Pode ser invocado diretamente pelo usuário via `/oxe-dashboard` para visualizar o swarm ativo.
+- Não modifica arquivos de código. Apenas lê `.oxe/swarm/` e atualiza artefatos de board.
+</context>
+
+---
+
+## Estrutura do BOARD.md
+
+```markdown
+# Swarm Board — <run_id>
+
+**Objetivo:** <texto>
+**Status:** running | paused | completed | failed
+**Iniciado:** <timestamp> | **Atualizado:** <timestamp>
+**Wave atual:** <N> de <total>
+
+## Progresso
+
+| ID | Tarefa | Agente | Wave | Status | Verificação | Revisão |
+|----|--------|--------|------|--------|-------------|---------|
+| T1 | Criar service de importação | builder-backend | 1 | ✅ done | passed | aprovado |
+| T2 | Criar componente de upload | builder-frontend | 1 | 🔄 running | — | — |
+| T3 | Criar migration | builder-storage | 1 | ⏳ pending | — | — |
+| T4 | Testes de integração | builder-backend | 2 | ⏳ pending | — | — |
+
+## Bloqueios ativos
+
+| Task | Agente | Razão | Desde |
+|------|--------|-------|-------|
+| — | — | — | — |
+
+## Quality Gates
+
+| Gate | Condição | Status |
+|------|----------|--------|
+| G1 | Cobertura ≥ 80% | ⏳ pendente |
+| G2 | Arquivo de alto risco revisado | ⏳ pendente |
+
+## Log de eventos (últimos 5)
+
+| Timestamp | Evento |
+|-----------|--------|
+| ... | Scout concluído: 12 arquivos mapeados |
+| ... | Builder-backend iniciou T1 |
+```
+
+---
+
+## Estrutura do BOARD.json
+
+```json
+{
+  "run_id": "...",
+  "updated_at": "ISO8601",
+  "status": "running",
+  "current_wave": 1,
+  "total_waves": 2,
+  "tasks": [
+    {
+      "id": "T1",
+      "title": "...",
+      "agent": "builder-backend",
+      "wave": 1,
+      "status": "done | running | pending | blocked | failed",
+      "verification": "passed | failed | null",
+      "review": "approved | rejected | null",
+      "files_changed": [],
+      "started_at": "ISO8601",
+      "completed_at": null
+    }
+  ],
+  "blockers": [],
+  "quality_gates": [
+    {"id": "G1", "condition": "coverage >= 80%", "status": "pending | passed | failed"}
+  ],
+  "agents": {
+    "scout": "done",
+    "builders": {"builder-backend": "running", "builder-frontend": "pending"},
+    "reviewer": "pending",
+    "verifier": "pending"
+  }
+}
+```
+
+---
+
+## Operações disponíveis
+
+### update_task_status(task_id, status, extra)
+Atualiza status de uma tarefa em BOARD.json e regenera tabela em BOARD.md.
+
+### add_blocker(task_id, agent, reason)
+Adiciona à seção "Bloqueios ativos" em BOARD.md e ao array `blockers` em BOARD.json.
+
+### resolve_blocker(task_id)
+Remove da seção de bloqueios. Registra resolução no log.
+
+### update_gate(gate_id, status)
+Atualiza status do gate em ambos os artefatos.
+
+### append_log(event_text)
+Adiciona linha ao log de eventos (mantém últimos 10).
+
+<success_criteria>
+- [ ] BOARD.md renderiza tabela legível a qualquer momento do swarm.
+- [ ] BOARD.json é fonte de verdade para todos os agentes lerem estado das tasks.
+- [ ] Bloqueios visíveis imediatamente após registro.
+- [ ] Quality gates rastreados com status atual.
+</success_criteria>

package/oxe/workflows/swarm/scout.md

@@ -0,0 +1,170 @@
+# OXE — Workflow: swarm/scout (Scout Agent)
+
+<objective>
+Executar reconhecimento do codebase antes que qualquer Builder toque um arquivo.
+Produz o mapa completo de arquivos relevantes, padrões, riscos e candidatos a testes —
+informação que permite ao Coordinator fazer decomposição e File Ownership sem surpresas.
+</objective>
+
+<context>
+- Invocado por `swarm-mode.md` Fase 2.
+- Aplicar `oxe/workflows/references/reasoning-discovery.md`: explorar antes de concluir; separar fatos, inferências e lacunas.
+- Persona: `researcher.md` (exploração) + instinto de `executor.md` (write set mínimo — Scout não modifica código).
+- Nunca modifica arquivos do projeto. Apenas lê e produz artefatos em `.oxe/swarm/scout/`.
+- Parâmetros de entrada: `objective`, `intent_tags`, `run_id`.
+</context>
+
+---
+
+## Fase 1 — Mapeamento de Módulos
+
+Com base nos `intent_tags`, identificar os módulos do projeto relevantes ao objetivo:
+
+1. Usar Glob para localizar diretórios e arquivos por padrão (ex.: `src/**/*.ts`, `app/**/*.tsx`)
+2. Para cada módulo relevante:
+   - Nome do módulo
+   - Caminho raiz
+   - Responsabilidade (inferida de exports, README local, comentários de topo de arquivo)
+   - Tamanho (estimativa de linhas, arquivos)
+   - Dependências internas (quais outros módulos ele importa)
+
+Gravar `.oxe/swarm/scout/CODEBASE-MAP.md`:
+```markdown
+# Codebase Map — <run_id>
+
+**Objetivo:** <texto>
+**Domínios relevantes:** <intent_tags>
+
+## Módulos identificados
+
+| Módulo | Caminho | Responsabilidade | Arquivos | Dependências |
+|--------|---------|-----------------|----------|--------------|
+| auth   | src/auth/ | Autenticação JWT | 8 | db, config |
+```
+
+---
+
+## Fase 2 — Padrões de Código
+
+Identificar as convenções em uso nos módulos relevantes:
+
+- Naming conventions (camelCase? snake_case? PascalCase para classes?)
+- Estrutura de arquivos (barrel exports? index.ts por pasta?)
+- Padrão de imports (absolute paths? aliases? relative?)
+- Padrão de testes (Jest? Vitest? Localização dos testes? `__tests__/` ou `.spec.ts` colocado?)
+- Padrão de erros (throw? Result type? Either? callbacks?)
+- Padrão de tipos (interfaces separadas? types inline? schemas Zod?)
+
+Gravar `.oxe/swarm/scout/PATTERNS.md`:
+```markdown
+# Padrões Detectados — <run_id>
+
+## Naming
+- ...
+
+## Estrutura de arquivos
+- ...
+
+## Testes
+- ...
+
+## Tipos
+- ...
+```
+
+---
+
+## Fase 3 — Mapa de Riscos
+
+Para cada arquivo candidato a modificação:
+
+| Critério | Risk Level |
+|----------|-----------|
+| Importado por 5+ outros módulos | high |
+| Contém lógica de auth / pagamento / dados sensíveis | high |
+| Arquivo de configuração global (env, db config) | high |
+| Módulo com cobertura de testes < 50% | med |
+| Arquivo tocado nos últimos 7 dias (git log) | med |
+| Arquivo isolado com testes adequados | low |
+
+Gravar `.oxe/swarm/scout/RISK-MAP.md`:
+```markdown
+# Risk Map — <run_id>
+
+| Arquivo | Risk Level | Motivo | Agente sugerido |
+|---------|-----------|--------|----------------|
+| src/auth/jwt.ts | high | auth crítica + 12 importadores | builder-backend |
+```
+
+---
+
+## Fase 4 — File Candidates
+
+Para cada arquivo que provavelmente precisa ser criado ou modificado para satisfazer o objetivo:
+
+Gravar `.oxe/swarm/scout/FILE-CANDIDATES.json`:
+```json
+[
+  {
+    "file": "src/import/import.service.ts",
+    "action": "create | modify",
+    "domain": "backend",
+    "risk_level": "low",
+    "suggested_agent": "builder-backend",
+    "rationale": "novo service de importação"
+  }
+]
+```
+
+---
+
+## Fase 5 — Test Candidates
+
+Para cada arquivo de código candidato, identificar o arquivo de teste correspondente:
+
+Gravar `.oxe/swarm/scout/TEST-CANDIDATES.json`:
+```json
+[
+  {
+    "code_file": "src/import/import.service.ts",
+    "test_file": "src/import/import.service.spec.ts",
+    "exists": false,
+    "existing_coverage_pct": null,
+    "test_strategy": "unit | integration | e2e"
+  }
+]
+```
+
+---
+
+## Fase 6 — Handoff para Coordinator
+
+Emitir mensagem em `.oxe/swarm/MESSAGES.ndjson`:
+```json
+{
+  "ts": "ISO8601",
+  "from": "scout",
+  "to": "coordinator",
+  "type": "handoff_summary",
+  "run_id": "...",
+  "payload": {
+    "modules_mapped": N,
+    "files_candidates": M,
+    "high_risk_files": K,
+    "patterns_detected": ["..."],
+    "ready_for_task_graph": true
+  }
+}
+```
+
+Atualizar `.oxe/swarm/SWARM-RUN.json` → `agents.scout.status = "done"`.
+
+<success_criteria>
+- [ ] CODEBASE-MAP.md com todos os módulos relevantes ao objetivo.
+- [ ] PATTERNS.md com pelo menos naming, estrutura e testes.
+- [ ] RISK-MAP.md com risk_level para cada arquivo candidato.
+- [ ] FILE-CANDIDATES.json com ação (create/modify) e agente sugerido.
+- [ ] TEST-CANDIDATES.json com estratégia por arquivo.
+- [ ] Nenhum arquivo do projeto foi modificado.
+- [ ] Mensagem de handoff emitida para coordinator.
+</success_criteria>

package/oxe/workflows/swarm-mode.md

@@ -0,0 +1,280 @@
+# OXE — Workflow: swarm-mode (Swarm Mode)
+
+<objective>
+Orquestração multi-agente para objetivos complexos (3+ domínios, 8+ arquivos ou feature completa).
+Coordena 5 papéis em sequência controlada: Scout → Coordinator (Task Graph + File Ownership) → Builder(s) em paralelo → Reviewer → Verifier/Integrator.
+Ao final, aciona aprendizado: padrões → CANDIDATES.ndjson → LESSONS.md.
+</objective>
+
+<context>
+- Invocado por `conduct.md` quando `intent_score = complexo`.
+- Reaproveitamento obrigatório:
+  - `packages/runtime/src/scheduler/multi-agent-coordinator.ts` — coordenação parallel/cooperative
+  - `oxe/schemas/plan-agents.schema.json` v3 — blueprint de agentes
+  - `oxe/workflows/references/plan-agent-chat-protocol.md` — mensagens inter-agente
+  - `packages/runtime/src/compiler/graph-compiler.ts` — ExecutionGraph
+- Artefatos em `.oxe/swarm/` (run-scoped: `.oxe/swarm/<run_id>/` quando múltiplos runs ativos).
+- Aplicar `oxe/workflows/references/reasoning-planning.md` na fase de decomposição.
+- Aplicar `oxe/workflows/references/reasoning-execution.md` em cada Builder.
+- Aplicar `oxe/workflows/references/reasoning-review.md` no Reviewer.
+</context>
+
+---
+
+## Fase 1 — Inicialização do Swarm
+
+Gerar `run_id` único: `swarm-<YYYYMMDD>-<seq>`
+
+Criar `.oxe/swarm/SWARM-RUN.json`:
+
+```json
+{
+  "run_id": "swarm-YYYYMMDD-001",
+  "started_at": "ISO8601",
+  "status": "running",
+  "objective": "<objetivo do usuário>",
+  "intent_tags": [],
+  "memory_applied": false,
+  "agents": {
+    "scout": {"status": "pending"},
+    "coordinator": {"status": "pending"},
+    "builders": [],
+    "reviewer": {"status": "pending"},
+    "verifier": {"status": "pending"}
+  },
+  "task_graph": null,
+  "file_ownership": null,
+  "waves": [],
+  "quality_gates": []
+}
+```
+
+Criar `.oxe/swarm/BOARD.md` (tabela inicial):
+
+```markdown
+# Swarm Board — <run_id>
+
+**Objetivo:** <texto>
+**Status:** running
+**Iniciado:** <timestamp>
+
+| ID | Tarefa | Agente | Status | Arquivos |
+|----|--------|--------|--------|----------|
+| — | — | Scout | em andamento | — |
+```
+
+---
+
+## Fase 2 — Scout
+
+Invocar `oxe/workflows/swarm/scout.md` com o objetivo e intent_tags.
+
+O Scout produz (em `.oxe/swarm/scout/`):
+- `CODEBASE-MAP.md` — visão geral dos módulos relevantes ao objetivo
+- `PATTERNS.md` — padrões de código existentes (naming, estrutura, convenções)
+- `RISK-MAP.md` — arquivos críticos, arquivos compartilhados, riscos de regressão
+- `FILE-CANDIDATES.json` — `[{file, domain, risk_level: low|med|high, suggested_agent}]`
+- `TEST-CANDIDATES.json` — `[{test_file, covers, existing_coverage_pct}]`
+
+Ao completar, atualizar `SWARM-RUN.json` → `agents.scout.status = "done"`.
+
+---
+
+## Fase 3 — Coordinator: Task Graph + File Ownership
+
+O Coordinator (Conductor) usa os artefatos do Scout para:
+
+### 3.1 Decomposição em tarefas
+
+Decompor o objetivo em tarefas Tn seguindo os princípios de `oxe/personas/planner.md`:
+- Cada tarefa: domínio claro, mutation_scope explícito, critério de aceite verificável
+- Agrupar em ondas: tarefas sem dependência → mesma onda
+
+### 3.2 Atribuição de Builders
+
+Para cada domínio detectado, criar um Builder com:
+- `id`: `builder-<domínio>` (ex.: `builder-backend`, `builder-frontend`)
+- `persona`: persona mais adequada ao domínio (via mapeamento de conduct.md Fase 3)
+- `taskIds`: tarefas atribuídas
+- `model_hint`: fast | balanced | powerful
+
+### 3.3 File Ownership
+
+Criar `.oxe/swarm/FILE-OWNERSHIP.json`:
+
+```json
+{
+  "run_id": "...",
+  "created_at": "ISO8601",
+  "locks": [
+    {
+      "file": "src/api/import.ts",
+      "owner_agent": "builder-backend",
+      "status": "locked",
+      "locked_at": "ISO8601"
+    }
+  ],
+  "free": []
+}
+```
+
+**Regra de conflito:** se dois Builders têm o mesmo arquivo em seu write_set → serializar em waves sequenciais (não paralelas). Registrar decisão em `.oxe/swarm/DECISIONS.md`.
+
+### 3.4 Atualizar artefatos
+
+Gravar `.oxe/swarm/TASK-GRAPH.json`:
+```json
+{
+  "run_id": "...",
+  "tasks": [
+    {"id": "T1", "title": "...", "domain": "...", "agent": "builder-backend", "wave": 1, "depends_on": [], "mutation_scope": [], "verify": "..."}
+  ],
+  "waves": [[["T1", "T2"]], [["T3"]]]
+}
+```
+
+Gravar `plan-agents.json` conforme schema v3 em `oxe/schemas/plan-agents.schema.json`.
+
+Atualizar `BOARD.md` com todas as tarefas.
+
+---
+
+## Fase 4 — Builders (execução em ondas)
+
+Para cada onda, executar os Builders em paralelo (sem conflito de arquivo validado na Fase 3):
+
+Cada Builder opera com o protocolo de `oxe/personas/executor.md`:
+1. Ler tarefa(s) atribuída(s) + contexto de memória (inject de `conduct.md` Fase 2)
+2. Discovery mínimo (confirmar arquivos, padrões)
+3. Implementar com write set declarado no `FILE-OWNERSHIP.json`
+4. Verificar (critério de aceite da tarefa)
+5. Registrar resultado em `.oxe/swarm/BOARD.json`:
+   ```json
+   {"task_id": "T1", "agent": "builder-backend", "status": "done", "files_changed": [], "verification": "passed"}
+   ```
+6. Emitir mensagem de handoff em `.oxe/swarm/MESSAGES.ndjson` para o próximo agente
+
+Se verificação falhar:
+- Registrar em `.oxe/swarm/BLOCKERS.ndjson`: `{"task_id": "...", "agent": "...", "reason": "...", "ts": "..."}`
+- Atualizar BOARD.md com status `blocked`
+- Coordinator decide: retry | replan local | escalar para usuário
+
+---
+
+## Fase 5 — Reviewer
+
+Após cada onda de Builders, invocar `oxe/personas/verifier.md` como Reviewer:
+
+Para cada tarefa concluída:
+1. Ler arquivos modificados pelo Builder
+2. Verificar: padrões seguidos? Critério de aceite satisfeito? Sem side effects não declarados?
+3. Gravar `.oxe/swarm/reviews/<task_id>-REVIEW.md`:
+   ```markdown
+   ## Review — T1
+   **Status:** aprovado | reprovado
+   **Checklist:** [lista]
+   **Observações:** [texto ou —]
+   ```
+4. Se reprovado: Builder refaz → nova revisão (máx 2 tentativas por tarefa antes de escalar)
+
+Atualizar BOARD.md.
+
+---
+
+## Fase 6 — Quality Gates
+
+Antes de passar para o Verifier, avaliar gates automáticos baseados em `risk_score`:
+
+| Condição | Gate |
+|----------|------|
+| Algum arquivo com `risk_level: high` foi modificado | Gate humano obrigatório |
+| Cobertura de testes abaixo do threshold do projeto | Gate automático: bloquear até cobrir |
+| Alguma tarefa falhou revisão 2x | Gate humano obrigatório |
+| Nenhuma condição acima | Gate automático: aprovado |
+
+Gravar `.oxe/swarm/QUALITY-GATES.md`:
+```markdown
+## Quality Gates — <run_id>
+
+| Gate | Condição | Status | Resolução |
+|------|----------|--------|-----------|
+| G1 | Arquivo de alto risco modificado | pendente | — |
+```
+
+---
+
+## Fase 7 — Verifier/Integrator
+
+Invocar `oxe/personas/verifier.md` como Verifier final:
+
+1. Integrar todas as mudanças (merge de worktrees se modo git_worktree)
+2. Executar suite de testes completa
+3. Verificar critérios de aceite do objetivo original (não só das tarefas individuais)
+4. Gravar `.oxe/swarm/FINAL-INTEGRATION.md`:
+   ```markdown
+   ## Integração Final — <run_id>
+
+   **Objetivo:** <texto>
+   **Status:** integrado | falhou
+   **Testes:** N passando / M falhando
+   **Critérios de aceite:** [checklist com resultado]
+   **Evidências:** [lista de arquivos de evidência]
+   ```
+5. Atualizar `.oxe/VERIFY.md` com resultado da integração
+
+---
+
+## Fase 8 — Learning
+
+Ao completar (sucesso ou falha parcial), acionar `oxe/workflows/distill.md`:
+
+- Entrada: `SWARM-RUN.json` + `FINAL-INTEGRATION.md` + `BLOCKERS.ndjson` + reviews
+- Saída: `.oxe/learning/CANDIDATES.ndjson` + atualização de `.oxe/global/LESSONS.md`
+
+---
+
+## Fase 9 — Eventos e Fechamento
+
+Emitir para `.oxe/OXE-EVENTS.ndjson`:
+```json
+{"type": "RunStarted", "payload": {"mode": "swarm", "run_id": "...", "objective": "..."}}
+{"type": "WorkItemCompleted", "payload": {"task_id": "T1", "agent": "..."}}
+...
+{"type": "RunCompleted", "payload": {"run_id": "...", "status": "completed|partial|failed"}}
+```
+
+Atualizar `SWARM-RUN.json` → `status = completed | partial | failed`.
+Atualizar `BOARD.md` com resumo final.
+
+---
+
+## Saída para o usuário
+
+```
+Swarm Mode — concluído
+Objetivo: <texto resumido>
+Agentes: Scout + N Builders + Reviewer + Verifier
+Tasks: X concluídas / Y falharam
+Integração: passou | falhou
+Quality Gates: N aprovados / M pendentes
+
+Arquivos principais alterados:
+- <lista>
+
+Learning: N lições registradas / M skill candidatas
+
+Próximo passo: <recomendação>
+```
+
+<success_criteria>
+- [ ] SWARM-RUN.json criado e atualizado em todas as fases.
+- [ ] Scout produz todos os 5 artefatos em `.oxe/swarm/scout/`.
+- [ ] FILE-OWNERSHIP.json sem conflitos entre Builders paralelos.
+- [ ] BOARD.md atualizado em tempo real por fase.
+- [ ] Cada tarefa tem review em `.oxe/swarm/reviews/`.
+- [ ] QUALITY-GATES.md avaliado antes da integração.
+- [ ] FINAL-INTEGRATION.md gerado pelo Verifier.
+- [ ] VERIFY.md atualizado.
+- [ ] Learning acionado (distill.md invocado).
+- [ ] OXE-EVENTS.ndjson atualizado.
+</success_criteria>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxe-cc",
-  "version": "1.11.0",
+  "version": "1.14.0",
   "description": "OXE — spec-driven workflows in .oxe/ with runtime enterprise, evidence-first verification and multi-runtime integrations (npx)",
   "license": "MIT",
   "author": "",
@@ -68,7 +68,7 @@
     "sync:cursor": "node scripts/sync-cursor-from-prompts.cjs",
     "release:doctor": "node scripts/release-doctor.cjs",
     "release:manifest": "node scripts/release-doctor.cjs --write-manifest",
-    "test:root": "node --test tests/install.test.cjs tests/oxe-project-health.test.cjs tests/oxe-dashboard.test.cjs tests/oxe-operational.test.cjs tests/oxe-azure.test.cjs tests/oxe-sdk.test.cjs tests/oxe-manifest.test.cjs tests/oxe-agent-install.test.cjs tests/oxe-install-resolve-full.test.cjs tests/oxe-health-extended.test.cjs tests/oxe-workflows-edge.test.cjs tests/oxe-sdk-edge.test.cjs tests/oxe-cli-edge.test.cjs tests/oxe-npm-version.test.cjs tests/oxe-scripts.test.cjs tests/oxe-retro-health.test.cjs tests/oxe-security-permissions.test.cjs tests/oxe-runtime-semantics.test.cjs tests/oxe-plugins.test.cjs",
+    "test:root": "node --test tests/install.test.cjs tests/oxe-project-health.test.cjs tests/oxe-dashboard.test.cjs tests/oxe-operational.test.cjs tests/oxe-azure.test.cjs tests/oxe-sdk.test.cjs tests/oxe-manifest.test.cjs tests/oxe-agent-install.test.cjs tests/oxe-install-resolve-full.test.cjs tests/oxe-health-extended.test.cjs tests/oxe-workflows-edge.test.cjs tests/oxe-sdk-edge.test.cjs tests/oxe-cli-edge.test.cjs tests/oxe-npm-version.test.cjs tests/oxe-scripts.test.cjs tests/oxe-retro-health.test.cjs tests/oxe-security-permissions.test.cjs tests/oxe-runtime-semantics.test.cjs tests/oxe-plugins.test.cjs tests/oxe-status-summary.test.cjs tests/oxe-integration-contracts.test.cjs",
     "test:runtime": "cd packages/runtime && npm test",
     "test:runtime-smoke": "node scripts/runtime-smoke-matrix.cjs",
     "test:runtime-real": "node scripts/runtime-real-suite.cjs",

package/packages/runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxe/runtime",
-  "version": "1.11.0",
+  "version": "1.14.0",
   "private": true,
   "license": "MIT",
   "description": "OXE agentic execution engine — enterprise runtime core",

package/vscode-extension/package.json

@@ -2,7 +2,7 @@
   "name": "oxe-agents",
   "displayName": "OXE Agents",
   "description": "Agentes OXE para GitHub Copilot Chat — cada fase do ciclo como um @agente no VS Code",
-  "version": "1.11.0",
+  "version": "1.14.0",
   "publisher": "oxe-cc",
   "license": "MIT",
   "engines": {