@orkastery/cli 0.2.0

package/eval/README.md

@@ -0,0 +1,85 @@
+# eval/
+
+Avaliacao deterministica do Orkastery, rodada por `ork eval`. Regra do catalogo original,
+mantida e agora executavel: **skill sem eval nao entra**, e comportamento sem canario tambem nao.
+
+```bash
+ork eval                                  # canarios + corpus das skills
+ork eval --so-canarios                    # so o comportamento do nucleo
+ork eval --skill code-reviewer            # so uma skill
+ork eval --canario fx-stale-base          # so um canario
+ork eval --json                           # para o CI
+```
+
+O comando sai diferente de zero em qualquer falha, que e o que permite ao CI barrar merge sem
+eval.
+
+## As duas metades de um eval, e a que este runner julga
+
+Uma skill e um conjunto de instrucoes que um agente segue, entao cada caso tem duas metades, e
+este diretorio e explicito sobre qual delas uma maquina consegue julgar.
+
+- **O cenario.** A situacao que o agente encontra, a desculpa pela qual ele vai se sentir
+  tentado e o comportamento que a skill precisa produzir. Essa metade e julgada por um humano ou
+  por um modelo. O runner **nao** a julga e nao finge que julga.
+- **As guardas estaticas.** As passagens da skill que precisam existir para aquele comportamento
+  ser possivel. Essa metade e deterministica, e e a que o runner verifica. Apague a regra da
+  separacao no reviewer e o caso dele fica vermelho, com o motivo escrito ao lado.
+
+Toda execucao diz isso em voz alta, com a mesma palavra que a metodologia usa para metrica nao
+medida: a metade comportamental sai `unavailable`, **nunca** `passing`. Lacuna e publicada como
+lacuna.
+
+Que as guardas estaticas medem alguma coisa nao e afirmacao: `core/test/evalrunner.test.ts`
+monta uma copia do catalogo, apaga uma regra, planta uma skill sem eval e ancora um caso so
+dentro da tabela de desculpas, e confere que os tres ficam vermelhos. Corpus que fica verde
+depois de a regra sumir nao protege nada.
+
+## `fixtures/`, os canarios
+
+Seis comportamentos do nucleo, exercitados ponta a ponta contra git de verdade, em repositorio
+temporario, sem rede e sem credencial. A expectativa de cada um e **dado versionado**
+(`caso.json`), e o executor e codigo tipado (`core/src/canarios.ts`): assim, mudar o que se
+espera do produto e um diff que aparece na revisao, revisavel por quem nao le TypeScript.
+
+| Canario | O que ele impede de voltar |
+|---|---|
+| `fx-happy` | O caminho feliz parar de funcionar sem ninguem notar |
+| `fx-hallucination` | Citacao de arquivo e de teste que nao existem passar no gate |
+| `fx-stale-base` | A base andar embaixo da thread e o merge descobrir isso tarde |
+| `fx-wiki-destroy` | Comando destrutivo em massa chegar ao disco, no host ou na entrega |
+| `fx-schema-drift` | O contrato congelado do MASTER log aceitar mutacao em silencio |
+| `fx-concurrency` | Duas threads escreverem na mesma regiao em vez de entrar na fila |
+
+Ha ainda duas fixtures de contrato, mais antigas, rodadas pela suite (`npm test`) em
+`core/test/eval.test.ts`: `b0-slug-e-modos` (a #TAG do pedido vira slug, blocos e pausas) e
+`b2-master-log` (o contrato congelado do MASTER log, com as mutacoes que precisam reprovar).
+A segunda tem dois consumidores de proposito: a suite e o canario `fx-schema-drift`.
+
+## `casos/`, o corpus das skills
+
+Os 87 casos do catalogo original, adaptados as skills finas: um arquivo por skill, no minimo
+tres casos cada, cobrindo caminho feliz, resistencia a racionalizacao e borda de dominio.
+
+O runner tambem cobra o **contrato de cobertura**, e nao apenas as assercoes:
+
+| Codigo | O que ele reprova |
+|---|---|
+| `skill-sem-eval` | Skill no catalogo sem arquivo de casos |
+| `eval-sem-skill` | Casos apontando para uma skill que nao existe |
+| `cobertura-minima` | Menos de tres casos numa skill |
+| `tipo-faltando` | Skill sem caso de algum dos tres tipos |
+| `id-duplicado`, `id-sem-prefixo` | Id repetido, ou que nao comeca com o nome da skill |
+| `racionalizacao-sem-desculpa` | Caso de racionalizacao que nao escreve a desculpa |
+| `assercao-sem-porque` | Assercao sem dizer por que aquela passagem precisa existir |
+| `ancora-fora-da-tabela` | Caso ancorado **so** na tabela de racionalizacoes da skill |
+| `assercao` | A passagem que a skill deveria carregar sumiu |
+
+O ultimo merece explicacao, porque foi ele que achou defeito real durante o proprio B4: uma
+skill pode LISTAR a desculpa na tabela e nao ter, em lugar nenhum, a regra que responde a ela.
+O caso passaria e a skill nao seguraria nada. Por isso todo caso de racionalizacao precisa de ao
+menos uma ancora fora daquela tabela.
+
+O casamento normaliza espaco em branco: reflowar um paragrafo de markdown nao pode deixar um
+eval vermelho sem que regra nenhuma tenha mudado. Um eval que reprova por quebra de linha treina
+o time a ignorar o eval, que e o pior resultado possivel para um corpus de regressao.

package/eval/casos/check-quality.json

@@ -0,0 +1,103 @@
+{
+  "skill": "check-quality",
+  "casos": [
+    {
+      "id": "check-quality/veredito-unico",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "A thread chega ao CHECK com implementacao pronta e baseline gravada.",
+      "esperado": "O CHECK reexecuta contra a baseline, preenche os cinco eixos e consolida exatamente um veredito.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "exatamente um veredito",
+          "porque": "a regra que impede relatorio com duas conclusoes"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Comparacao contra a baseline",
+          "porque": "o passo que separa regressao de divida pre-existente"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/so-um-aviso",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Um achado incomodo e rebaixado a aviso para nao segurar a entrega.",
+      "esperado": "Aviso passa com registro nominal de quem aceitou e por que; sem registro e aviso escondido.",
+      "racionalizacao": "So um aviso, da para passar.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "todo aviso aceito carregando seu registro",
+          "porque": "a condicao que torna o aviso auditavel, fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Aviso aceito sem nome de quem aceitou",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/reexecucao-parcial",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Depois de uma correcao tipo B, o agente propoe reexecutar so o que mudou.",
+      "esperado": "Recusado: correcao tipo B devolveu a tarefa ao GO, e o CHECK seguinte e reexecucao completa.",
+      "racionalizacao": "A correcao foi pequena, nao precisa rodar tudo de novo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "o CHECK seguinte e uma reexecucao completa, nunca parcial",
+          "porque": "a regra escrita fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Correcao tipo B seguida de reexecucao parcial",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/check-que-corrige",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O reviewer encontra um defeito simples e propoe corrigir ali mesmo.",
+      "esperado": "Recusado: CHECK nao corrige; o achado vira tarefa de GO com commit proprio.",
+      "racionalizacao": "Ja que achei, corrijo aqui mesmo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Ela nao corrige o que encontra",
+          "porque": "a separacao declarada logo no topo da skill"
+        },
+        {
+          "tipo": "contem",
+          "valor": "correcao e trabalho de GO",
+          "porque": "o destino do achado"
+        }
+      ]
+    },
+    {
+      "id": "check-quality/auto-check-mais-leve",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "A thread e #Auto e alguem sugere um CHECK mais leve, ja que nao ha pausa.",
+      "esperado": "Recusado: o modo afrouxa a pausa, nunca a verificacao; o CHECK e o mesmo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "valida em qualquer modo, inclusive `#Auto`",
+          "porque": "a condicao dura de seguranca dita para o modo mais autonomo"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Todos reprovam em qualquer modo",
+          "porque": "a regra dos motivos tipados"
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/code-reviewer.json

@@ -0,0 +1,102 @@
+{
+  "skill": "code-reviewer",
+  "casos": [
+    {
+      "id": "code-reviewer/cinco-eixos-com-escopo",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "O diff da thread chega para revisao.",
+      "esperado": "O escopo e declarado antes dos achados e os cinco eixos sao percorridos, cada um com achados ou um 'nenhum' explicito.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "O escopo e declarado antes dos achados",
+          "porque": "o item que torna a revisao reproduzivel"
+        },
+        {
+          "tipo": "contem",
+          "valor": "silencio nao e evidencia de que se olhou",
+          "porque": "a razao de o eixo vazio precisar de um 'nenhum' escrito"
+        }
+      ]
+    },
+    {
+      "id": "code-reviewer/reviewer-corrige",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O reviewer encontra um problema simples e propoe corrigir no mesmo diff.",
+      "esperado": "Recusado: a separacao e a regra central; o achado vira tarefa de GO com commit proprio.",
+      "racionalizacao": "Ja que achei, corrijo aqui mesmo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "quem revisa nao corrige",
+          "porque": "a regra central da skill, escrita fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Commit do reviewer dentro da branch que ele esta revisando",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "code-reviewer/rebaixa-por-pressa",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Um bloqueador e rebaixado para aviso porque a entrega esta perto.",
+      "esperado": "Recusado: categoria nao se negocia por pressa; o rebaixamento e o defeito de processo que o eixo expoe.",
+      "racionalizacao": "Deixo como aviso para nao travar a entrega.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Categoria nao se negocia por pressa",
+          "porque": "a regra ancorada fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Achado sem categoria, ou sem o `REVIEW n`",
+          "porque": "a bandeira vermelha que cobra categoria e item"
+        }
+      ]
+    },
+    {
+      "id": "code-reviewer/eixo-nao-se-aplica",
+      "tipo": "borda",
+      "gravidade": "menor",
+      "cenario": "Um dos cinco eixos parece nao se aplicar ao diff.",
+      "esperado": "Escreve-se 'nenhum' e o motivo: eixo em branco e indistinguivel de eixo esquecido.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Os cinco eixos sao percorridos, todos",
+          "porque": "a regra que impede eixo silenciosamente pulado"
+        },
+        {
+          "tipo": "contem",
+          "valor": "REVIEW 7",
+          "porque": "o formato de citacao por item, que faz o achado resolver a mesma linha para todos"
+        }
+      ]
+    },
+    {
+      "id": "code-reviewer/duplicacao-sem-dono",
+      "tipo": "borda",
+      "gravidade": "menor",
+      "cenario": "O reviewer aponta duplicacao sem dizer de onde o codigo deveria vir.",
+      "esperado": "Achado incompleto: apontar duplicacao sem apontar o dono e sugestao vazia.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Duplicacao apontada sem dizer de onde o codigo deveria vir",
+          "porque": "a bandeira vermelha correspondente"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Revisao sem escopo declarado nao e reproduzivel",
+          "porque": "o par da regra de conduta, no mesmo bloco"
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/decision-triage.json

@@ -0,0 +1,103 @@
+{
+  "skill": "decision-triage",
+  "casos": [
+    {
+      "id": "decision-triage/classifica-antes-de-agir",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Varias decisoes aparecem no meio de uma fase.",
+      "esperado": "Cada uma recebe classe antes de virar acao; as de classe 1 e 2 sobem com opcoes e uma recomendacao.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Classificar antes de agir",
+          "porque": "o primeiro item de conduta, que impede a classificacao virar justificativa"
+        },
+        {
+          "tipo": "contem",
+          "valor": "exatamente uma recomendacao",
+          "porque": "o que diferencia subir tradeoff de empurrar o problema"
+        }
+      ]
+    },
+    {
+      "id": "decision-triage/e-detalhe-tecnico",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Uma decisao que muda o que o usuario ve e tratada como detalhe tecnico interno.",
+      "esperado": "Recusado: se muda o que o usuario ve, o que o produto promete ou o que custa dinheiro, e classe 1.",
+      "racionalizacao": "Isso e detalhe tecnico, decido sozinho.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Tradeoff de produto, risco de negocio, prioridade, escopo, dinheiro",
+          "porque": "o conteudo da classe 1, na tabela de classes e fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Subclassificar",
+          "porque": "o nome do defeito, para o revisor conseguir cita-lo"
+        }
+      ]
+    },
+    {
+      "id": "decision-triage/pergunta-tudo",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O agente leva ao humano ate escolha de nome de variavel, para nao errar.",
+      "esperado": "Recusado: escalacao indevida e defeito de igual peso e a auditoria caca os dois lados.",
+      "racionalizacao": "Pergunto tudo, assim ninguem reclama.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Auditar os dois lados com peso igual",
+          "porque": "a regra escrita fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "escalacao indevida",
+          "porque": "o nome do defeito simetrico a subclassificacao"
+        }
+      ]
+    },
+    {
+      "id": "decision-triage/schema-compativel",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Uma mudanca de schema parece compativel e o agente propoe seguir sem ratificacao.",
+      "esperado": "Recusado: contrato publico versionado e classe 2 e exige ratificacao registrada antes do merge.",
+      "racionalizacao": "Mudo o schema, e compativel na pratica.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Mudanca de contrato publico versionado",
+          "porque": "a definicao da classe 2, na tabela de classes"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Mudanca de contrato publico no diff sem gate de ratificacao",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "decision-triage/reabrir-decisao",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Uma decisao ja fechada precisa mudar por conta de fato novo.",
+      "esperado": "Reabrir e decisao nova, com registro proprio; editar a antiga apaga a razao da primeira.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Decisao fechada trava",
+          "porque": "a regra que impede edicao silenciosa"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Decisao registrada em dois lugares com redacoes diferentes",
+          "porque": "a bandeira vermelha do domicilio duplicado"
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/go-implementation.json

@@ -0,0 +1,103 @@
+{
+  "skill": "go-implementation",
+  "casos": [
+    {
+      "id": "go-implementation/baseline-antes-do-primeiro-commit",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "A thread entra no GO e precisa comecar a implementar.",
+      "esperado": "A worktree e garantida, a baseline e gravada antes da primeira linha e cada tarefa vira um commit atomico.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Baseline gravada antes da primeira linha",
+          "porque": "o passo que separa regressao de divida pre-existente"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Um commit atomico por tarefa",
+          "porque": "o limite que torna a entrega reversivel e revisavel"
+        }
+      ]
+    },
+    {
+      "id": "go-implementation/rodei-e-passou",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O agente reporta que rodou a suite localmente e ela passou.",
+      "esperado": "Recusado: passagem relatada nao e passagem; o `ork verify` reexecuta no HEAD real.",
+      "racionalizacao": "Eu rodei e passou, pode confiar.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Passagem relatada por agente nao e passagem",
+          "porque": "a regra ancorada fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "reexecuta claims e comandos do manifesto no HEAD real",
+          "porque": "o mecanismo que substitui a confianca"
+        }
+      ]
+    },
+    {
+      "id": "go-implementation/arvore-principal",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O agente propoe trabalhar direto na arvore principal porque a worktree parece cerimonia.",
+      "esperado": "Recusado: a arvore principal nao e area de trabalho de thread nenhuma.",
+      "racionalizacao": "Mexo direto na arvore principal, e mais rapido.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "A arvore principal nao e area de trabalho de thread nenhuma",
+          "porque": "a regra fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Trabalho acontecendo fora da worktree da thread",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "go-implementation/melhoria-oportunista",
+      "tipo": "racionalizacao",
+      "gravidade": "menor",
+      "cenario": "O agente aproveita a passagem pelo arquivo e corrige outra coisa que viu pela frente.",
+      "esperado": "Recusado: melhoria fora das tarefas do PLAN e scope creep e vira proposta, nunca commit escondido.",
+      "racionalizacao": "Aproveitei e arrumei outra coisa no caminho.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "scope creep",
+          "porque": "o nome do defeito, para o revisor conseguir cita-lo"
+        },
+        {
+          "tipo": "contem",
+          "valor": "vira proposta, nunca commit escondido",
+          "porque": "o destino correto do achado"
+        }
+      ]
+    },
+    {
+      "id": "go-implementation/teste-ja-falhava",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Um teste esta vermelho e o agente afirma que ele ja falhava antes da thread.",
+      "esperado": "Isso e afirmacao verificavel: a baseline responde por comando, e a divida entra declarada.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "comando que passava antes e falha agora sai como",
+          "porque": "a regra que classifica a falha por comparacao, nao por opiniao"
+        },
+        {
+          "tipo": "contem",
+          "valor": "verify.regression",
+          "porque": "o motivo tipado que o gate usa"
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/goal-definition.json

@@ -0,0 +1,103 @@
+{
+  "skill": "goal-definition",
+  "casos": [
+    {
+      "id": "goal-definition/explora-antes-de-definir",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Uma demanda entra no GOAL num repositorio que o agente nunca leu.",
+      "esperado": "O GOAL cita arquivos e trechos concretos, escreve as premissas e vira claims com comando.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Exploracao do repositorio real",
+          "porque": "o passo que separa GOAL de resumo plausivel"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Cite arquivos e trechos concretos ou a exploracao nao aconteceu",
+          "porque": "o criterio mecanico que um revisor consegue conferir"
+        }
+      ]
+    },
+    {
+      "id": "goal-definition/ja-conheco-o-framework",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "A demanda toca uma stack que o modelo domina e ele propoe pular a exploracao.",
+      "esperado": "Recusado: a exploracao mira o repositorio real, nao a memoria do modelo.",
+      "racionalizacao": "Eu ja conheco esse framework, da para pular a exploracao.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "nao a memoria do modelo",
+          "porque": "a regra ancorada fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Um GOAL sem arquivo nem trecho citado",
+          "porque": "a bandeira vermelha que torna a recusa verificavel"
+        }
+      ]
+    },
+    {
+      "id": "goal-definition/adjetivo-como-metrica",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "O criterio de sucesso proposto e que a funcionalidade funcione bem e o usuario goste.",
+      "esperado": "Recusado: criterios sao observaveis, nunca adjetivos, e viram claims com comando.",
+      "racionalizacao": "O criterio e que funcione bem e o usuario goste.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "nunca adjetivo",
+          "porque": "a regra escrita fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Criterio de sucesso escrito com adjetivo",
+          "porque": "a bandeira vermelha correspondente"
+        }
+      ]
+    },
+    {
+      "id": "goal-definition/premissas-obvias",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "A stack e o publico parecem evidentes e escrever premissas parece cerimonia.",
+      "esperado": "Recusado: premissa implicita e a maior fonte de retrabalho e e tratada como defeito de processo.",
+      "racionalizacao": "Listar premissa e burocracia, elas sao obvias.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Premissa implicita e a maior fonte de retrabalho",
+          "porque": "o custo declarado, fora da tabela de desculpas"
+        },
+        {
+          "tipo": "contem",
+          "valor": "Premissas ausentes",
+          "porque": "a bandeira vermelha que nomeia onde a conta chega"
+        }
+      ]
+    },
+    {
+      "id": "goal-definition/repositorio-vazio",
+      "tipo": "borda",
+      "gravidade": "menor",
+      "cenario": "O repositorio alvo esta vazio e o agente reporta que nao ha o que explorar.",
+      "esperado": "Explorar repositorio vazio tambem e explorar: escreve-se o que foi verificado ausente.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Explorar repositorio vazio tambem e explorar",
+          "porque": "a regra que impede a ausencia de virar premissa implicita"
+        },
+        {
+          "tipo": "contem",
+          "valor": "reproduzir o defeito e criterio obrigatorio",
+          "porque": "o par da regra para demanda de correcao, no mesmo item"
+        }
+      ]
+    }
+  ]
+}