convez.ai
AgenteDevOps & InfraestruturaAvançado
23ag1

Completely — Agente de Código com Garantia de Qualidade

23ag1/completely

Torna agentes de código verificáveis: prova > promessa

Ver no GitHub
InicialPluginScore · de 0 a 100

Agent para Claude Code que transforma afirmações vagas ('pronto') em evidências verificáveis, através de um avaliador independente com falha padrão. Unifica planejamento GSD e coordenação Beads sob gates determinísticos (lint, tipos, bloqueios de comando perigoso, commit obrigatório) e contrato sem-stubs, eliminando mentiras estruturais do agente.

Instalação

$npx convez-ai 23ag1/completely

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
6
Forks
0
Acompanhando
1
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Supervisionar agentes de código com verificação independente de progresso
  • Bloquear estruturalmente erros comuns (stubs silenciosos, testes desabilitados, código sem commit)
  • Coordenar planejamento GSD com execução paralela e serialização automática por zona de escrita

Veredito

Completely é uma solução de engenharia ambiental rara: em vez de pedir ao agente que seja honesto, torna a desonestidade estruturalmente impossível. Ideal para quem não confia em promessas e quer gates + avaliação adversarial automática em produção.

README

A tradução para o português deste README ainda está na fila.

completely

Claude Code plugin Stars License: MIT Contracts

Make a coding agent hard to lie to you. completely turns "the agent said it's done" into "here's the proof, graded by an independent checker" — unifying GSD (planning depth) and Beads (the spine) under deterministic gates and a default‑FAIL evaluator, in one install.

Short CLI: cmpl. Slash commands: /completely:*.

It holds itself to the same bar: this repo is built through its own engine, every deterministic contract is in cmpl test (39 passing), and during development its own default‑FAIL evaluator caught a real over‑graded task and a flagship‑loop crash before they could ship.


The problem this solves

Coding agents fail in the same boring ways, and a longer CLAUDE.md doesn't fix it (an essay nobody executes):

  • claim "done" without actually running anything;
  • quietly downscope a tool into a stub;
  • disable a failing test to go green;
  • close a task with the code uncommitted, or lose context between sessions;
  • you stack GSD + a loop + Beads and they fight (three task queues, drift, no single truth).

completely fixes these structurally — by engineering the environment so they can't happen — instead of asking nicely in a prompt.

Before → after

WithoutWith completely
"I ran the tests, all green" (no output)acceptance proven by evidence in Beads, graded by a read‑only default‑FAIL evaluator
you hope edits were linteda hook lints/type‑checks every edit; cmpl check runs all checks in one terse pass
rm -rf, force‑push slip througha guard hook blocks them (exit 2)
a task closes with code uncommitteda commit‑before‑close gate refuses bd close while the tree is dirty
GSD todos + a loop's plan + Beads = 3 queuesone spine (Beads); GSD plans land as native epics + dependency waves
"minimal version" stub, silentlyno‑stub contract — downscope only via an explicit blocked
an upstream update breaks your wiringcmpl doctor quarantines on drift; cmpl update re‑syncs

What you get (one install)

  • Spine — Beads holds status, memory (comments/notes), and coordination. Status never lives in markdown.
  • Planning — GSD (discuss → plan → plan‑checker). Plans land straight into Beads as an epic + worker‑contract tasks + dependency waves + goal‑backward must_haves.
  • Execution — one engine, two modes: supervised (GSD wave subagents, human gates) or unattended (fresh‑context loop over bd ready). The loop is parallel by default — it dispatches tasks whose write‑zones are disjoint concurrently and serializes same‑file ones.
  • Quality floor — gate hooks (lint/types on every edit · dangerous‑command block · commit‑before‑close), a default‑FAIL evaluator (with an adversarial claim‑vs‑refute mode), a worker‑contract cmpl lint, and one‑pass cmpl check.
  • Adaptive — frontend and backend in one system, detected automatically (no modes to pick).
  • Upgrade‑safe — overlays (it never edits your GSD install) + version‑drift quarantine.

The autonomous loop is real, not a diagram: it runs a fresh claude -p worker per task and was driven end‑to‑end during this project's own development.

Install

claude plugin marketplace add 23ag1/completely
claude plugin install completely@completely

Requires Beads (bd) — the only hard dependency. GSD (planning) and claude‑mem (memory) are optional; a loop dependency is not required (completely's loop is built in). On install, a Setup hook reports what's missing. To auto‑install (with consent):

cmpl setup --install            # install missing deps via their real channels
cmpl setup --install --dry-run  # preview the exact commands first
DependencyRequired?Install command
Beads (bd)yes — the spinenpm i -g @beads/bd · brew install beads
GSDoptional — planningnpx get-shit-done-cc --global
claude‑memoptional — memoryclaude plugin install claude-mem@thedotmack

Then, in any repo:

cmpl setup          # report deps; add --install to auto-install missing ones
/completely:init    # discovery: new vs existing, stack + architecture, scaffold the thin layer
cmpl quality        # install a pre-commit gate (cmpl check) + starter lint configs
/completely:plan    # plan a feature straight into Beads (no markdown) — discovery + decompose
cmpl check          # run all checks in one pass → "clean" or just the failure
cmpl run --dry-run  # see the queue + parallel plan, then `cmpl run` to drive bd ready

Manual / non‑plugin: git clone https://github.com/23ag1/completely && cd completely && ./install.sh --project /path/to/repo

Command surface

cmpl (short CLI):

CommandDoes
cmpl checkrun all configured quality checks, one pass, terse output
cmpl lintenforce the worker‑contract (acceptance+design+write‑zone) on Beads tasks
cmpl plan-applymaterialize a structured plan → Beads epic+tasks+waves (the Beads‑first path, no markdown)
cmpl rundrive bd ready — supervised (GSD) or unattended (parallel, fresh‑context loop)
cmpl emit <PLAN.md>migration: import an existing GSD PLAN.md (frontmatter must_haves/waves) → Beads
cmpl syncmigration: import existing markdown task lists → Beads
cmpl setupverify upstreams + wire project Beads
cmpl qualityscaffold pre‑commit gate + lint configs
cmpl doctorupstream version drift + overlay quarantine
cmpl updatere‑check + re‑sync after upstreams change
cmpl testrun the contract regression suite

Slash: /completely · /completely:init · /completely:plan · /completely:run · /completely:check

Configure

A completely.toml (optional — sane defaults) customizes the pipeline without touching scripts: [stack], [architecture], [check].commands, [skills].prefer, [tools].lazy. Your own skills and rules compose on top — completely layers, it never overrides. Knobs: CMP_PARALLEL (worker concurrency, default 4) · CMP_ALLOW_DIRTY_CLOSE · CMP_PUSH.

How it fits with your tools

completely is the quality + verification + glue layer. It does not own your planning or task queue — it routes to the best existing tool for each concern and keeps everything in Beads. See docs/TOOL-COMPATIBILITY.md for the full design and plugin/core/ for the principle, roles, routing, the task engine, and token‑economy.

Caveats (honest)

  • Token cost. Multi‑agent verification costs multiples of a single session — keep a fast path for trivial edits. A real quality/$ measurement (cmpl bench) is on the roadmap, not yet published.
  • Hooks can be finicky — prefer explicit cmpl/bd commands over fragile session hooks.
  • Trust — install skills/MCP only from sources you trust.

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados