Superpowers Evals

Laboratório de avaliação comportamental para superpowers. Quorum conduz CLIs reais de agentes de codificação (Claude, Codex, Antigravity, Gemini, Kimi, OpenCode, Pi e Copilot) através de um agente de QA Gauntlet e os avalia com base em critérios de aceitação de cenários mais verificações pós-execução determinísticas.

Código, CLI, caminhos e prosa em linha usam quorum em minúsculas; a forma capitalizada Quorum aparece em cabeçalhos e na tabela de atores.

Esta não é uma suíte de benchmark genérica. É um laboratório de avaliação para conformidade de fluxo de trabalho: acionamento de habilidades, comportamento de worktree, coordenação de subagentes, reflexos de verificação, qualidade de revisão e padrões de modelagem de custos.

Modelo de Segurança

quorum possui dois modos de execução muito diferentes:

Verificações estáticas/de unidade são seguras para CI pública. Elas executam biome, tsc e bun test. Não chamam APIs de modelo nem lançam CLIs de agentes.
Avaliações ao vivo são operações de mantenedor confiável. Elas lançam Claude Code, Codex CLI, Antigravity CLI, Gemini CLI, Kimi Code, OpenCode CLI, Pi CLI, ou Copilot CLI em modos permissivos e coletam transcrições brutas, chamadas de ferramentas, estado do sistema de arquivos e logs de sessão.

A CI pública deve permanecer no lado estático/de unidade dessa linha. Nunca adicione chaves de API, invocações quorum run … ao vivo ou lançamentos de agentes em modo perigoso à CI pública.

Risco da Avaliação ao Vivo

Avaliações ao vivo executam o Agente de Codificação sob teste com amplo poder de execução:

Claude usa --dangerously-skip-permissions.
Codex usa --dangerously-bypass-approvals-and-sandbox.
Antigravity usa --dangerously-skip-permissions e depende de autenticação local de navegador/keyring para agy.
Gemini usa --skip-trust --approval-mode=yolo; autenticação por chave de API é o padrão, com autenticação OAuth opcional para execuções locais confiáveis.
Kimi usa --yolo.
OpenCode usa --dangerously-skip-permissions.
Pi usa listas de permissões explícitas de ferramentas e autenticação por chave de API em um diretório de configuração local de execução.
Copilot usa --allow-all.

quorum fixa o HOME de cada Agente de Codificação (mais os diretórios base XDG e TMPDIR) em um home descartável por execução em <run>/home — o lançador insere o token $QUORUM_HOME_ENV construído por src/agents/home-env.ts (xdgHomeEnv, a única fonte da verdade). O diretório de configuração de cada agente é colapsado sob esse home (Claude .claude, Codex .codex, Gemini ., OpenCode ., Antigravity ., Copilot .copilot, Kimi .kimi-code, Pi .pi/agent), então o Agente de Codificação encontra sua configuração através do próprio padrão e nunca vê o , , , , , , real do host, nem outros estados relativos ao home, plugins instalados ou sessões anteriores. O provisionamento semeia a configuração — e as credenciais OAuth do host que cada agente precisa — nesse home descartável antes da inicialização, portanto não há login em tempo de execução. Copilot também prepara o plugin local Superpowers sob o home isolado, usa um ambiente externo na lista de permissões e escreve um contendo segredos com chmod 0600 dentro do diretório de execução. Isso reduz o raio de explosão, mas não é uma sandbox. Os lançadores OpenCode e Copilot usam adicionalmente ambientes na lista de permissões, mas Agentes de Codificação ao vivo ainda executam com amplo poder de sistema de arquivos e execução de comandos.

Execute avaliações ao vivo apenas a partir de um ambiente local confiável:

Exporte apenas a chave de API necessária para o Agente de Codificação selecionado.
Evite executar com segredos amplos de produção ou pessoais no ambiente.
Trate results/, logs de sessão brutos, artefatos de chamadas de ferramentas/estado de sessão e entradas do Agente Gauntlet como sensíveis.
Não confirme nem cole artefatos brutos de execução sem verificá-los primeiro.

Início Rápido

Instale e execute as portas estáticas:```bash bun install bun run check bun run quorum check

Execute um cenário local ou de emergência fora do contêiner:```bash
export SUPERPOWERS_ROOT=/path/to/superpowers
export ANTHROPIC_API_KEY=...
bun run quorum run scenarios/triggering-writing-plans --coding-agent claude
bun run quorum show <run-dir>

O Gauntlet-Agent (driver de QA) autentica-se na Anthropic com ANTHROPIC_API_KEY por padrão. Para executá-lo a partir de uma assinatura logada do Claude, defina CLAUDE_CODE_OAUTH_TOKEN (de claude setup-token) no ambiente (ex. .env); o harness passa o token adiante e o gauntlet o prefere à chave de API. Nota: uma assinatura tem limites de uso dimensionados para uso interativo — lotes run-all de alta concorrência podem atingi-los, então a chave de API continua sendo a melhor opção para carga pesada.

Os nomes dos agentes são claude, codex, antigravity, gemini, kimi, opencode, pi e copilot. Nem todo cenário é válido para todos os agentes.

BREAKING (eixo de credenciais): claude-haiku e claude-sonnet não são mais nomes de agentes separados. Para executar o harness do Claude contra Sonnet ou Haiku:```bash bun run quorum run scenarios/ --coding-agent claude --credential sonnet bun run quorum run scenarios/ --coding-agent claude --credential haiku

A credencial padrão do agente `claude` é `opus`.

## Dispositivo de Avaliação Compartilhado

As avaliações remotas ao vivo compartilhadas são projetadas para serem executadas a partir de um host de dispositivo confiável com um único pacote de credenciais abençoadas, proveniência exata de repo/ref, bloqueios de host e registros de jobs recuperáveis. Os agentes devem usar o helper do dispositivo assim que ele existir no host configurado:```bash
evals-appliance doctor --json
evals-appliance prepare --json --superpowers-ref <branch-tag-or-sha>
evals-appliance run-all --json --detach \
  --superpowers-ref <branch-tag-or-sha> \
  -- --tier sentinel \
     --coding-agents claude,codex,kimi \
     --jobs 4
evals-appliance status --json <job-id>
evals-appliance show --json <job-id>
evals-appliance costs --json <job-id>
evals-appliance cancel --json <job-id>

A interface alvo e as regras de operação estão em docs/appliance-runbook.md, respaldadas por docs/superpowers/specs/2026-06-18-shared-eval-appliance-design.md. doctor é somente leitura. prepare retorna lock_busy em vez de alterar referências enquanto um job ativo estiver em execução. O acesso ao host e os procedimentos de break-glass específicos do provedor são intencionalmente mantidos fora deste repositório público; use o runbook de operações privado para esses detalhes. Os comandos bun run quorum ... e scripts/evals-container exec quorum ... permanecem como fluxos de trabalho locais ou break-glass confiáveis para avaliações ao vivo compartilhadas.

Runtime do Contêiner

O runtime do Docker é a receita principal para execuções reais de suíte. Ele mantém o checkout de evals, o checkout do Superpowers em teste, credenciais, fontes de autenticação e todos os artefatos de execução no host enquanto o quorum é executado dentro de um contêiner rico de workspace Ubuntu.

Crie .env.container ou passe um arquivo env explícito para up:```dotenv ANTHROPIC_API_KEY=... OPENAI_API_KEY=... OPENROUTER_API_KEY=... # Pi default: OpenRouter GLM 5.2 GEMINI_API_KEY=... # or GEMINI_AUTH_TYPE=oauth-personal KIMI_MODEL_API_KEY=... # unless using mounted Kimi OAuth PI_PROVIDER=... # only for raw/custom Pi env auth outside the default credential PI_MODEL=... PI_API_KEY=... COPILOT_GITHUB_TOKEN=...

Em seguida, construa, inicie e valide o contêiner:```bash
scripts/evals-container build
scripts/evals-container down || true
scripts/evals-container --env-file .env.container up
scripts/evals-container exec evals-tool-versions
scripts/evals-container exec quorum check

O wrapper monta este checkout de evals em /workspace/evals, o checkout pai do Superpowers em /workspace/superpowers, e o host results/ em /workspace/evals/results. Substitua o checkout do Superpowers com --superpowers-root <dir> quando o caminho pai padrão não for o sistema em teste.

A construção da imagem precisa de um checkout local do Gauntlet. O wrapper o descobre a partir de GAUNTLET_ROOT ou de uma instalação global bun link; use --gauntlet-root <dir> com build para escolher explicitamente.

As credenciais são montagens somente leitura. Por padrão, up usa .env.container primeiro, depois .env, e monta o primeiro encontrado em /run/evals/credentials.env. Passe --env-file <file> antes de up para escolher explicitamente. O wrapper não passa o ambiente do host por completo; apenas o shim quorum dentro do contêiner utiliza o arquivo dotenv, então scripts/evals-container exec bash ... não recebe automaticamente credenciais de eval ativas. Use down antes de alterar a montagem do arquivo env-file em um contêiner existente.

As fontes de autenticação OAuth/arquivo também são somente leitura. Os diretórios existentes ~/.codex, ~/.gemini, ~/.kimi-code e ~/.pi são montados em /auth/codex, /auth/gemini, /auth/kimi-code e /auth/pi. Use --auth codex=<dir>, --auth gemini=<dir>, --auth kimi=<dir> ou --auth pi=<dir> para substituir uma fonte.

Comece com a suíte sentinela:```bash scripts/evals-container exec quorum run-all
--tier sentinel
--coding-agents claude,codex,kimi
--jobs 4

for agent in gemini opencode pi copilot; do scripts/evals-container exec quorum run-all
--tier sentinel
--coding-agents "$agent"
--jobs 1 done

Execute os mesmos comandos sem `--tier sentinel` para a suíte completa pronta.
`run-all` escreve cada lote em `results/batches/<batch-id>/` e cada execução
em `results/<scenario>-<agent>-<os>-<timestamp>-<nonce>/`; renderize um lote
com:```bash
scripts/evals-container exec quorum show <batch-id>

run-all imprime um heartbeat periódico de atividade (⋯ … · running N/jobs · done D · queued Q · [agent:scenario, …]); ajuste-o com --heartbeat-seconds <n> (0 desabilita). Interromper um lote — Ctrl-C, ou o fechamento da sessão exec — interrompe-o graciosamente: a fila é cancelada, execuções em andamento recebem SIGINT (e são registradas como paradas), e o rodapé do lote ainda é escrito, de modo que finished_at nunca fica nulo.

O runtime do contêiner não monta o socket do Docker, publica portas do painel, ou inclui IDEs de desktop. A imagem omite o instalador de desktop agy do Antigravity; execute o Antigravity no lado do host até que haja um caminho de instalação headless:```bash bun run quorum run-all --coding-agents antigravity --jobs 1

Para varreduras de host agrupadas de todos os agentes, credenciais por agente, detalhes de montagem de autenticação e solução de problemas, use [docs/coding-agent-care-and-feeding.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/HEAD/docs/coding-agent-care-and-feeding.md).

## Windows Runtime

Para avaliações no Windows 11, use `--os windows` (apenas hosts Linux+KVM):```bash
bun run quorum run scenarios/<name> --coding-agent claude --os windows

Consulte docs/windows/eval-runtime.md para configuração e implementação.

Atores Canônicos

Mantenha os atores em ordem; confundi-los é o erro de triagem mais comum. Esses nomes são usados em todos os lugares — documentos, saída da CLI, código, nomes de arquivos, mensagens de commit.

Uma execução envolve dois LLMs — o Gauntlet-Agent (testador de QA) e o Coding-Agent (sujeito). Modelos separados, registros separados, custos de token separados.

Guias do Operador

docs/scenario-authoring.md — anatomia do cenário, elaboração de história/CA, auxiliares de configuração, verbos de verificação e armadilhas de autoria.
docs/appliance-runbook.md — regras operacionais do appliance remoto compartilhado para agentes.
docs/coding-agent-care-and-feeding.md — credenciais, varreduras, notas de runtime por agente e resolução de problemas.
docs/adding-a-coding-agent.md — lista de verificação para adicionar um novo agente alvo, lançador, provisionador, normalizador e teste de fumaça.
docs/superpowers/skills/triaging-a-failing-eval.md — atlas de atribuição para execuções sem aprovação.
docs/baselines/ — linhas de base atuais conhecidas como boas por backend.

Eixo de Credenciais

A dimensão da avaliação é (cenário, agente de codificação, credencial, so). credentials.yaml na raiz do repositório define credenciais nomeadas; cada entrada declara o modelo, protocolo de conexão (api: openai-chat, openai-responses, anthropic ou gemini), base_url opcional para endpoints não padrão, tipo de autenticação (api-key, subscription ou oauth), api_key_env opcional, as famílias de runtime que atende (harnesses) e substituições de agendador opcionais (max_concurrency, launch_spacing_seconds) e um bloco (, ).

Cada YAML de agente declara uma default_credential. Sobrescreva em tempo de execução:```bash

run against a named credential

bun run quorum run scenarios/ --coding-agent claude --credential sonnet

run-all against multiple credentials (incompatible cells are skipped)

bun run quorum run-all --coding-agents claude,opencode --credentials sonnet,haiku,opencode_gpt5 --jobs 4

`quorum check` valida `credentials.yaml` e o `default_credential` de cada agente.

O agendador ajusta seu limite de concorrência e trava de limitação de taxa na **limiterKey** da credencial — a `base_url` da credencial, se definida, caso contrário o nome da credencial, concatenado com sua `api` (ex.: `https://…/v1|openai-chat` ou `opus|anthropic` para uma credencial nativa sem `base_url`). Células que compartilham uma limiterKey compartilham um limite e uma trava de limitação de taxa: uma resposta de limitação de taxa em qualquer célula ignora imediatamente todas as células restantes na fila para aquele endpoint.

Credenciais nomeadas padrão (consulte `credentials.yaml`): `opus`, `sonnet`, `haiku` (Claude harness), `codex_sub` (assinatura Codex), `kimi_default`, `openrouter_glm_5_2` (padrão Pi), `pi_default` (opt-in nativo do Pi OAuth), `opencode_gpt5`, `gemini_default`, `serf_default`, `glm_5_2_chat`, `glm_5_2_responses`, `ollama_local`.

### Campanhas Serf externas

Campanhas de modelo/provedor Serf de curta duração usam um arquivo de credenciais externo, não o `credentials.yaml` canônico do repositório. Passe-o explicitamente com `--credentials-file` para `quorum run`, `quorum run-all` ou `quorum check`. Mantenha o YAML real da campanha e todos os artefatos brutos de execução fora do Git: o YAML contém rótulos de roteamento e o nome da variável de ambiente da chave de API selecionada, nunca um valor de chave.

Cada predefinição de campanha deve fixar exatamente um modelo e um provedor, desabilitar fallbacks e não conter sobrescritas de prompt, amostragem, raciocínio, ferramenta ou limite de tokens. Forneça sua chave dedicada por meio do pacote de credenciais de tempo de execução confiável. A chave deve impor a política de dados pretendida da campanha, ter um limite de gastos da campanha e, para uma campanha de capacidade compartilhada, não ter vínculo BYOK. Uma comparação BYOK é uma campanha separada com uma chave separada e um arquivo candidato.

Antes da expedição, `run-all` analisa o arquivo externo uma vez e escreve seu instantâneo canônico em `results/batches/<batch-id>/credentials.snapshot.yaml`; cada filho recebe esse instantâneo imutável. Um `quorum run` direto escreve o mesmo instantâneo canônico em seu diretório de execução. Editar o YAML de origem após o início de um lote não pode alterar células posteriores. Os instantâneos contêm metadados de roteamento conhecidos pelo esquema e nomes de variáveis de ambiente, não valores secretos, mas permanecem parte dos artefatos de execução sensíveis.

Execute o teste de fumaça agnóstico ao agente primeiro, depois execute o cenário caro apenas para credenciais cujo veredito final do teste de fumaça seja `pass`:```bash
quorum run-all \
  --scenarios 00-quorum-smoke-hello-world \
  --include-drafts \
  --coding-agents serf \
  --credentials-file /secure/campaign.yaml \
  --credentials serf_example_a \
  --jobs 1

quorum run-all \
  --scenarios serf-builder-fractals \
  --coding-agents serf \
  --credentials-file /secure/campaign.yaml \
  --credentials serf_example_a \
  --jobs 1

--jobs 1 é a linha de base de latência/custo sequencial. Uma célula da matriz é uma tentativa paga; o agendador da campanha não repete ou refaz automaticamente uma célula. Renderize a comparação rotulada com quorum costs <batch-id>. Apenas as linhas finais pass são marcadas como comparáveis; fail e indeterminate permanecem visíveis, mas não classificadas, e medições ausentes são renderizadas como ausentes, não como zero. As colunas Charged, Estimated e Delta são custos do Coding-Agent. As colunas existentes --with-gauntlet são custos separados de harness do Gauntlet-Agent.

A aceitação ao vivo é trabalho manual de mantenedor confiável, nunca automação pública de CI:

Execute uma célula hello-world conhecida como boa com --jobs 1.
Inspecione verdict.json, trajectory.json, openrouter-generations.json, coding-agent-token-usage.json e quorum costs <batch-id>. Confirme modelo, provedor, versão preset, BYOK é falso, buckets de token/cache, duração, custo cobrado, estimativa, delta e rótulos dos candidatos, incluindo quantização e data do catálogo.
Execute uma célula Fractals com --jobs 1; exija pass final, todas as verificações determinísticas, entrega commitada no main-checkout e uma linha de comparação completa.
Execute dois candidatos hello-world com --jobs 2; confirme atribuição distinta sem chaves, gerações, rótulos ou economia contaminados de forma cruzada.
Só então execute uma célula Fractals sequencial por candidato que passou no smoke test.

Publique apenas conclusões revisadas e higienizadas em uma nota datada em docs/experiments/, registrando tanto falhas quanto vitórias. O YAML da campanha externa e artefatos brutos permanecem fora do Git.

Core Commands```bash

bun run quorum list bun run quorum new my-new-scenario bun run quorum check my-new-scenario bun run quorum run scenarios/ --coding-agent bun run quorum run scenarios/ --coding-agent claude --credential sonnet bun run quorum run-all --coding-agents claude,codex --jobs 2 bun run quorum run-all --coding-agents claude --credentials sonnet,haiku --jobs 2 bun run quorum show bun run quorum costs

`quorum check` sem argumentos valida todos os cenários e o `credentials.yaml`.
`run-all` executa todos os cenários incluídos contra cada agente de codificação selecionado,
filtrados pela diretiva `# coding-agents:` de cada cenário.

## Vereditos e Artefatos

quorum produz um veredito de três valores:

- `pass` - O Gauntlet-Agent passou e todas as verificações posteriores passaram.
- `fail` - O Gauntlet-Agent falhou, ou uma verificação posterior falhou.
- `indeterminate` - falha de configuração/verificação prévia/captura/quorum, Gauntlet
  `investigate`, ou trace vazio quando verificações de trace estão presentes.

Códigos de saída são 0 para `pass`, 1 para `fail` e 2 para `indeterminate`.

Cada execução gera um diretório em `results/`:```text
results/<scenario>-<coding-agent>-<os>-<timestamp>-<nonce>/
|-- verdict.json                     composed result; start here
|-- gauntlet-agent/                  Gauntlet-Agent evidence
|-- coding-agent-workdir/            files the Coding-Agent produced
|-- home/                            throwaway Coding-Agent HOME
|-- trajectory.json                  normalized ATIF trace
`-- coding-agent-token-usage.json    Coding-Agent token cost, when priced

results/ está no gitignore porque artefatos de execução podem conter transcrições sensíveis, credenciais, chamadas de ferramentas e estado do sistema de arquivos.

Verificações Seguras

Estas são as verificações esperadas na CI e em PRs de rotina:```bash bun run check # biome ci . && tsc --noEmit && bun test — the full gate bun run quorum check # validate every scenario directory

`bun run check` é o único portão (Biome lint/format + full-strict `tsc` +
`bun test`); as etapas individuais são `bun run lint`, `bun run typecheck` e
`bun test`.

## Architecture

quorum é **TypeScript no Bun**. O console é `bun run quorum <cmd>` (uma
CLI [commander](https://github.com/tj/commander.js) em `src/cli/index.ts`,
também exposta como o comando `quorum`); o portão é `bun run check`
(Biome + full-strict `tsc` + `bun test`).

As formas que cruzam fronteiras de processos e arquivos — `verdict.json`, índices
de lote, economia, o resultado do Gauntlet, YAML do agente — são **esquemas zod**
em `src/contracts/`, validados em cada fronteira, para que um arquivo externo
malformado falhe ruidosamente em vez de corromper um veredito. A camada `cli/`
analisa comandos e os despacha para o pipeline `runner/` (um cenário × um
Coding-Agent) ou `run-all/` (a matriz). As diferenças por Coding-Agent residem
em dois fan-outs paralelos chaveados pelo nome do agente: `agents/` sementeia a
configuração do agente sob o diretório `$HOME` descartável por execução
(`<run>/home`), e `normalize/` transforma o log de sessão desse agente em um
trace uniforme de chamadas de ferramenta. Chamadas ao CLI do agente ao vivo e
outros subprocessos não hermétricos passam pela costura
`agents/command-runner.ts`, para que o conjunto de testes unitários injete mocks
e nunca lance um CLI real. `scheduler/` é o motor de concorrência compartilhado
sob `run-all/`. O painel é um pacote separado somente leitura que escaneia
`results/` e `grid-manifest.json`. `env.ts` é o único módulo que lê
`process.env`.```text
src/
  cli/                  commander CLI: run, list, new, check, show, costs, run-all, grid-manifest
    index.ts              command wiring + run / costs / run-all / grid-manifest actions
    render.ts             verdict renderer for triage (quorum show)
    render-batch.ts       batch-matrix renderer (quorum show <batch>)
    resolve-target.ts     run/batch target resolution; scenario.ts scenario loading
  runner/               per-run orchestration (one scenario × one Coding-Agent)
    index.ts              setup → pre-checks → gauntlet drive → capture → post-checks → compose
    context.ts            populate the Gauntlet-Agent context dir (HOWTO + launch-agent shim)
    phase.ts              phase.json (setup/agent/checks) for the dashboard
    stopped.ts            SIGINT → stopped (indeterminate) verdict; errors.ts staged run-error stages
  agents/               per-Coding-Agent provisioning (resolveAgent dispatch)
    index.ts              agent registry + dispatch (incl. the inline Claude/Default adapters)
    command-runner.ts     injectable subprocess seam (live CLIs faked in tests)
    <agent>.ts            codex/gemini/kimi/opencode/pi/copilot/antigravity adapters
  normalize/            session-log → normalized tool-call trace, one module per dialect
  capture/              session-log snapshot/diff + tool-call capture + token usage; cwd-filter
  obol/                 obol cost estimation (session-log + gauntlet sidecar)
  economics.ts          token-cost composition → coding-agent-token-usage.json
  composer.ts           three-valued verdict from the gauntlet + checks layers
  checks/               sources prelude.sh + checks.sh, runs pre()/post(), collects check records
    prelude.sh            bare-verb DSL: defines each check verb as a bash function that
                          delegates to the TS dispatchers (no bin/ shims, no PATH prepend)
  scheduler/            central concurrency dispatcher (one global slot pool, per-harness limits + spacing)
  run-all/              scenario × Coding-Agent matrix over the scheduler; batch index
  setup-helpers/        scenario fixture builders + the `setup-helpers` CLI (dispatch registry)
  contracts/            zod schemas at the JSON boundaries (verdict, batch, economics, gauntlet, agent-config)
  scaffold.ts           `quorum new` / `quorum check`
  setup-step.ts         runs scenario setup.sh (sources prelude.sh via BASH_ENV so bare verbs resolve)
  story-meta.ts         story.md frontmatter (quorum_max_time, quorum_tier, status)
  env.ts                the single process.env boundary
  paths.ts              repo root, UTC stamps, nonces
  invariant.ts          assertNever exhaustiveness guard for closed unions
  check/                typed check verbs: fs-verbs.ts (file/git/env + bootstrap),
                        dispatch.ts (table + `not`), transcript-dispatch.ts, record.ts (sole emitter)
  cli/check-tool.ts     the dispatcher behind every check verb function (file-exists,
                        file-contains, command-succeeds, git-*, assert-checkout-clean,
                        requires-tool, not, files-exist, the *-installed/hook/extension
                        checks); check-transcript.ts and setup-helpers/cli.ts are the
                        other two dispatchers the prelude delegates to
  cli/list-check-verbs.ts  prints the FS_VERBS verb set the prelude loops over (drift-proof)
coding-agents/          per-Coding-Agent material:
  <name>.yaml             CLI config
  <name>-context/         HOWTO prose and launchers for the Gauntlet-Agent
scenarios/              scenarios (one directory each)
fixtures/               shared static fixture repos (e.g. template-repo/, sdd-*/)
test/                   bun test suite
docs/                   design notes, specs, plans, testing protocols, baselines
packages/dashboard/     read-only web matrix UI: scan/view, typed HTML templates, SSE bus, Bun.serve

Triagem

Triar uma execução que não passou começa com:```bash bun run quorum show []

Em seguida, use [docs/superpowers/skills/triaging-a-failing-eval.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/HEAD/docs/superpowers/skills/triaging-a-failing-eval.md)
para o atlas de atribuição. Para verificações de autenticação, provisionamento e captura específicas do agente, use [docs/coding-agent-care-and-feeding.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/HEAD/docs/coding-agent-care-and-feeding.md).

Para a linha de base conhecida atualmente, veja [docs/baselines/](https://github.com/prime-radiant-inc/superpowers-evals/blob/HEAD/docs/baselines/).

## Regras de Contribuição

Este repositório herda o padrão de qualidade de `superpowers`.

- Um problema por PR.
- Não cometa artefatos de execução gerados ou segredos.
- Não adicione avaliações ao vivo ao CI público.
- Use o modelo de PR e explique o risco de segurança/laboratório de avaliação para alterações que toquem em configurações do Coding-Agent, execução de shell, auxiliares de configuração, ferramentas de verificação ou entrada do Gauntlet-Agent.
- Alterações na metodologia de avaliação de modelagem de comportamento precisam de evidências, não apenas prosa.

## Atualização do Submódulo Pai

`superpowers-evals` é consumido por `superpowers` como o submódulo `evals`.
Após qualquer PR ser mesclado em `main` aqui, abra um PR de acompanhamento contra o repositório pai `superpowers` com destino a `dev` que atualize o ponteiro do submódulo `evals` para o commit mesclado de `superpowers-evals`.

Não trate uma mesclagem de `superpowers-evals` como totalmente propagada até que esse PR de atualização do submódulo pai exista.

---

Relatórios de segurança → [SECURITY.md](https://github.com/prime-radiant-inc/superpowers-evals/blob/HEAD/SECURITY.md).

Gauntlet	Framework de QA de uso geral; a CLI `gauntlet`. Um testador de caixa preta.	repositório `github.com/prime-radiant-inc/gauntlet`; no `PATH` como `gauntlet` (via `bun link` ou `GAUNTLET_ROOT`)
Gauntlet-Agent	O LLM dentro do Gauntlet que dirige o Coding-Agent e autoavalia-se contra os ACs da história.	modelo ex. `claude-sonnet-4-6`; fluxo de eventos → `<run>/gauntlet-agent/results/<runId>/run.jsonl`; veredito → `result.{json,md}`
Coding-Agent	O agente em teste — o SUT. Instâncias: Claude, Codex, Antigravity, Gemini, Kimi, OpenCode, Pi, Copilot.	configuração + registro de sessão em seu diretório `$HOME` descartável em `<run>/home/…`; os arquivos que escreve → `<run>/coding-agent-workdir/`
Quorum	O wrapper TypeScript/Bun. Detém a configuração, adaptação do Coding-Agent, verificações determinísticas e o veredito final.	repositório `superpowers-evals/src/`; `<run>/verdict.json`

superpowers-evals

Mais Populares

Sobre