CONTINUUM

Recuperação semântica universal e verificável para agentes de IA de longa duração com checkpoints semânticos, ledger de ações idempotente e log encadeado por hash como um servidor MCP com negação por padrão

GitHub

Documentação

CONTINUUM Banner

CONTINUUM: Recuperação semântica verificável para agentes de IA de longa duração. Checkpoints semânticos (não despejos de conversa), um registro de ações idempotente que recusa efeitos colaterais duplicados e um log de eventos encadeado por hash à prova de adulteração, tudo exposto como um servidor MCP com negação por padrão. Independente de framework, Python 3.11+.

Visite o site do CONTINUUM

_{Se o CONTINUUM ajudar seus agentes a se recuperarem, por favor, dê uma estrela no repositório. Isso ajuda outras pessoas a descobri-lo e mantém boas primeiras issues chegando.}

_{English | 简体中文 | Español | 日本語 | Português | 한국어}

Conteúdo

Por quê · Início rápido · Como funciona · Onde o CONTINUUM se encaixa · Recursos · Extensão de segurança · Verificação empírica · Integração MCP · Integração de frameworks · Conceitos principais · Arquitetura · API e CLI · Roteiro · O que o CONTINUUM não é · Trabalhos relacionados · Status e limitações · Contribuindo · Licença

Por quê

Agentes de IA modernos executam tarefas longas (centenas de chamadas de LLM, invocações de ferramentas, gravações em arquivos e bancos de dados). Quando eles falham, a resposta usual é reproduzir tudo do zero, o que duplica trabalho, duplica efeitos colaterais, desperdiça tokens e perde decisões.

O CONTINUUM faz uma pergunta mais restrita e mais difícil: um agente pode retomar a partir de uma representação semântica compacta do estado de sua tarefa enquanto verifica de forma independente que esse estado ainda é válido no ambiente atual? Seu diferencial tem três partes:

Checkpoints semânticos: uma representação compacta e versionada do que o agente precisa para continuar, não um despejo de conversa.
Revalidação independente do ambiente: cada componente do checkpoint é verificado contra o ambiente atual antes da retomada, com a propagação de obsolescência pelo grafo de dependências.
Estado com proveniência: cada fato rastreia sua origem, então o progresso relatado pelo agente nunca é autocertificado.

Início rápido

Publicado no PyPI como continuum-agent 0.1.2: pip install continuum-agent (pip install continuum-agent==0.1.2 para fixar). Tags de lançamento também enviam wheels compilados anexados aos GitHub Releases.

Caminhos que não exigem clone nem instalação local:

Caminho	Como
Instalar do PyPI	`pip install continuum-agent==0.1.2`, depois `continuum --help`
Instalar com Homebrew	`brew install wized2/continuum/continuum`, depois `continuum --help`
Assistir à recuperação de falhas de ponta a ponta	`docker run --rm ghcr.io/cyrax321/continuum`
Usar a CLI via Docker	`docker run --rm ghcr.io/cyrax321/continuum continuum --help`
Executar a CLI sem clonar	`uvx --from git+https://github.com/Cyrax321/CONTINUUM.git continuum --help`
Windows PowerShell (a partir de um clone)	`powershell -ExecutionPolicy Bypass -File .\try-it.ps1` ou `powershell -ExecutionPolicy Bypass -File .\try-it.ps1 cli --help`
Assistir à mesma recuperação em um notebook
O mesmo notebook, no Binder
Ambiente de desenvolvimento completo no navegador

A imagem Docker é publicada no GHCR pelo CI a cada push para main e a cada tag de lançamento (.github/workflows/docker-publish.yml). O Codespace é definido em .devcontainer/. O notebook é examples/demo.ipynb: sua primeira célula instala o CONTINUUM apenas quando a importação falha, então o único arquivo roda no Colab, no Binder e a partir de um clone.

git clone https://github.com/Cyrax321/CONTINUUM.git
cd CONTINUUM

uv venv && source .venv/bin/activate     # macOS / Linux; Windows: .venv\Scripts\activate

# Contributors (recommended): library + CLI + test tooling + framework integrations
uv pip install -e ".[dev]"

# Or pick only what you need: . (minimal), [mcp], [browser], [kubernetes],
# [otel], [langgraph], [openai], [langchain], [attest], [postgres]

# Or skip the clone entirely:
uv pip install git+https://github.com/Cyrax321/CONTINUUM.git
uv pip install "continuum-agent[mcp] @ git+https://github.com/Cyrax321/CONTINUUM.git"

Fallback do pip: substitua uv pip install por pip install em todos os comandos acima.

Adaptadores de ambiente opcionais:

uv pip install -e ".[browser]" habilita BrowserAdapter; execute playwright install chromium separadamente para instalar o binário do navegador.
uv pip install -e ".[kubernetes]" habilita KubernetesAdapter; kubectl e um cluster configurado permanecem como pré-requisitos externos.

Se você usar pip em vez de uv, execute pip install -e ".[browser]" ou pip install -e ".[kubernetes]" com os mesmos pré-requisitos externos.

Verifique:

continuum --help                 # CLI entrypoint
continuum-mcp --help             # MCP server entrypoint (needs [mcp] or [dev])
pytest -q                        # ~3680 collected, ~3,680 passed, ~0 skipped on a minimal env (exact counts vary)
ruff check src/ tests/ examples/ && ruff format --check src/ tests/ examples/
mypy src/continuum               # the three gates CI enforces

A biblioteca principal tem uma dependência de runtime (pydantic>=2.7); todo o resto é opcional. O mapa completo de pacotes, a matriz de extras, a configuração de teste do Postgres e a verificação por comando estão em references/install.md.

Conecte um agente de codificação em dois minutos

Para Claude Code, Gemini CLI ou Codex, você não escreve Python e não precisa de um arquivo de prompt:

continuum start my-task --goal "What the agent should do"
continuum hooks install claude-code --with-gate   # also: gemini, codex

A partir daí, todo arquivo que o agente escreve é capturado como evidência encadeada por hash, sua sessão começa com um briefing automático de status, efeitos colaterais não reivindicados registrados em .continuum/gate.json são recusados antes de dispararem, e uma nova sessão após qualquer falha retoma com próximos passos executáveis. Nenhum CLAUDE.md é necessário.

Exemplo mínimo de biblioteca, registrar e recuperar:

from continuum import EventType, Run, SQLiteStorage, project

store = SQLiteStorage("agent.db")
store.create_run(Run(run_id="run_4821", goal="Analyze 10,000 documents"))
store.append_event("run_4821", EventType.RUN_STARTED, {"goal": "Analyze 10,000 documents", "total": 10_000})

for i, doc in enumerate(documents):
    analyze(doc)
    store.append_event("run_4821", EventType.WORK_COMPLETED, {"doc": i})

# After a crash, a new process picks up exactly where it stopped:
state = project("run_4821", store.read_events("run_4821"))
print(state.progress.completed)            # already done, not repeated
print(store.verify_events("run_4821").ok)  # True, chain intact after the crash

Execute a prova você mesmo:

python examples/crash_recovery_agent.py   # real process kill, real side effect
python examples/context_compaction.py     # transcript lost, checkpoint survives
python examples/model_switch.py           # Model A dies, Model B resumes safely
python scripts/mcp_smoke.py               # real subprocess, real JSON-RPC traffic

O kit e2e-autonomy-test/ roteiriza uma tarefa real de lote de faturas, um kill forçado no meio da execução e uma nova sessão de retomada, depois pontua a caixa de saída, o registro e a cadeia de eventos fora de banda. A execução 1 pontuou 7/7 mecânicas contra uma sessão real do Claude Code. Passo a passo completo em references/e2e.md.

Como funciona

O CONTINUUM separa o contexto do LLM (temporário) do estado durável da tarefa (permanente). Em vez de salvar o histórico da conversa, ele constrói um checkpoint semântico, a informação mínima verificada necessária para continuar.

CONTINUUM how it works

A explicação detalhada, o modelo de projeção e o contexto de recuperação estão em references/architecture.md.

Onde o CONTINUUM se encaixa

Quatro preocupações se sobrepõem em todo agente de longa duração. O CONTINUUM possui apenas a última e toca as outras três por meio de costuras explícitas. Nenhum concorrente é nomeado e nenhuma afirmação é feita sem um módulo enviado ou uma suíte publicada que já a imprima.

Camada	Responde	Como se conecta (módulos enviados ou saída publicada)
Orquestração	Como o agente chama ferramentas e progride em direção a um objetivo?	Fora do CONTINUUM. Pontos de conexão são enviados em `src/continuum/adapters/generic.py` (`GenericAgentAdapter`), `src/continuum/adapters/thin.py` (hooks do CrewAI, AutoGen, Pydantic AI), `src/continuum/mcp/server.py` (MCP stdio), `src/continuum/hooks.py` e `src/continuum/clienthooks.py` (hooks de ciclo de vida de CLI de codificação), `src/continuum/gateway.py` (impondo proxy HTTP para qualquer linguagem) e `src/continuum/otel.py` (ponte OpenTelemetry). Receitas estão em `docs/recipes/` e `references/adapters.md`.
Execução durável	O que aconteceu antes de uma falha e o que pode ser reproduzido sem perder trabalho?	Log de eventos encadeado por hash `src/continuum/events.py` com `verify()` e `trusted_through`, armazenamento durável `src/continuum/storage/sqlite.py` (WAL, `synchronous=FULL`, schema v6) e `src/continuum/storage/postgres.py` mais `src/continuum/storage/migrations.py`, checkpoints orientados por política `src/continuum/checkpoint/manager.py` e `src/continuum/checkpoint/policy.py` que reproduzem a lacuna em `restore()`. Passo a passo em `docs/recovery_walkthrough.md` (saída de `examples/recovery_walkthrough.py`).
Plano de controle	Qual execução está ativa, quem pode agir sobre ela e para onde vai a saída?	Registro de execuções e hierarquia pai/filho `src/continuum/storage/` e `src/continuum/recovery/family.py` (`continuum tree`), autorização por allowlist `src/continuum/mcp/authz.py` (`CONTINUUM_MCP_MUTATING_CLIENTS` / `CONTINUUM_MCP_TOKEN`), superfícies de apresentação `src/continuum/dashboard/app.py` e `src/continuum/serve/server.py`, CLI `src/continuum/cli/main.py` (`continuum runs`, `continuum tree`, `continuum health`).
Substrato de verificação	Dado o checkpoint no tempo T e o mundo como está agora, ainda é seguro e correto continuar?	`src/continuum/state/validator.py` (obsolescência `dependency -> evidence -> finding -> decision` mais `PlanStep.depends_on`), `src/continuum/provenance_map.py` (`Origin` a `REQUIRES_REVIEW` até `REVIEW_CONFIRMED`), `src/continuum/actions/ledger.py` com `src/continuum/actions/idempotency.py` e `src/continuum/gate.py` / `src/continuum/gateway.py` (reivindique antes de disparar, recusa duplicatas, levanta `UnknownSideEffect` para reconciliação), `src/continuum/replayguard.py` (guarda portátil), `src/continuum/pinning.py` e `src/continuum/replay_similarity.py` (correção de reprodução), `src/continuum/budgets.py` (limites de tentativas), `src/continuum/recovery/engine.py` + `src/continuum/recovery/contract.py` + `src/continuum/recovery/planner.py` + `src/continuum/recovery/observations.py` (severidade máxima `RESUME < ... < ABORT`, contrato selado com `evidence` / `reason` / `next_allowed_action` / `human_steps`), `src/continuum/checkpoint/rewind.py` (rebobinação atômica de estado duplo), `src/continuum/analysis/prefix_trust.py` (confiança consultiva). Verificações publicadas: `docs/recovery_walkthrough.md`, `benchmarks/fault_injection/` (suíte que imprime `detection_rate` / `unsafe_resume_rate`), `src/continuum/benchmark/phase6/` (suíte de correção de recuperação), `docs/RESULTS.md` e o visual regenerável abaixo.

Cada linha acima é rastreável a um caminho que existe em main no commit marcado. Nada nesta tabela reafirma um número de benchmark; benchmarks vivem apenas na saída da suíte que já imprimem. Veja docs/research.md para a lista completa de suítes publicadas e documentos de design.

Recuperação de falhas, de verdade

A imagem abaixo não é uma simulação. É a saída de python demo-run/generate_crash_visual.py, que executa demo-run/worker.py até os._exit(9) no documento 399, chama continuum resume --env dataset=v4 e mostra o caminho de recusa (REQUEST_HUMAN, safe:false, saída 21), reconcilia o efeito colateral incerto com uma sonda e então retoma do mesmo banco de dados e termina sem trabalho duplicado. A transcrição também é salva como docs/assets/crash-recovery.txt para auditoria.

Regenere:

python demo-run/generate_crash_visual.py
# or: python scripts/generate_crash_visual.py

Crash recovery: hard kill mid-batch, refusal, reconcile, resume

Passo a passo completo com código está em docs/recovery_walkthrough.md (examples/recovery_walkthrough.py). O harness mínimo de benchmark está em references/bench.md (continuum benchmark).

Recursos

Capacidade	O que ela oferece
Checkpoints semânticos	Estado compacto, versionado e inspecionável, não um despejo de transcrição
Registro de ações idempotente	Recusa efeitos colaterais externos duplicados; expõe os incertos para reconciliação
Revalidação de ambiente	Cada componente do checkpoint é verificado contra o mundo atual antes de retomar
Estado ciente de proveniência	Progresso relatado pelo agente é marcado `REQUIRES_REVIEW`, nunca autocertificado
Mecanismo de recuperação	Sete modos de recuperação com um contrato de próxima ação determinístico e selado
Servidor MCP com negação por padrão	Treze ferramentas, divisão somente leitura/mutação, lista de permissões do chamador
Adaptadores de framework	Integrações genéricas para Python, OpenAI Agents SDK, LangGraph e LangChain
Loop de planejamento seguro	Verificação de observação com dois sinais eleva ramos de alto risco para REQUIRES_REVIEW
Revalidação periódica	Ambiente re-verificado em um cronograma, capturando desvios no meio da execução dentro de um ciclo
Log à prova de adulteração	Log de eventos encadeado por hash (55 tipos de eventos) com verificação de integridade
Portão de imposição	Chamadas de efeitos colaterais não reivindicadas são recusadas antes de disparar; mensagens de negação ensinam o protocolo de reivindicação
Ganchos de observação	Cada arquivo que um CLI de codificação escreve torna-se evidência verificada por digest, fora do controle do modelo
Briefing de sessão	Novas sessões aprendem o estado da execução deterministicamente no início, incluindo o resumo de raciocínio da última sessão
Sondas de reconciliação	Comandos registrados resolvem efeitos colaterais incertos automaticamente; humanos veem apenas o restante
Orientação executável	Retomar/validar renderiza próximos passos como comandos executáveis, não status
Gateway HTTP de imposição	Chamadas de saída em qualquer idioma exigem reivindicações; respostas as resolvem a partir da realidade
Ponte OpenTelemetry	Spans de chamadas de ferramentas do rastreamento de produção tornam-se evidência com zero mudanças de código
Índice de ações	Consultas de idempotência entre execuções são leituras indexadas, não varreduras de log completo
Fixação de versão	Hashes de prompt/ferramenta/modelo afirmados pelo chamador são armazenados por reivindicação; desvios são sinalizados na retomada
Orçamentos de tentativa	Limites de tentativas por tipo de ação aplicados no momento da reivindicação; agentes veem tentativas restantes
Pai/filho multi-agente	Retomada do pai compõe o pior estado da família; filho incerto bloqueia o pai
Nova tentativa informada	Resumos de falha escritos pelo mecanismo são injetados em retomadas pós-recuperação
Semântica de fork	Continuações divergentes ramificam em execuções filhas com autoridade renovada
Compactação de log	Prefixo pré-âncora arquivado verbatim; log ativo limitado para execuções de meses
Rastreamento de concessão consumida	Referências de autoridade de uso único são marcadas como gastas no status terminal; reutilização após restauração é recusada (`GRANT_DENIED`), defendendo o caminho de checkpoint-restauração contra Ressurreição de Autoridade
Atestado de cadeia	`continuum attest` assina a cabeça da cadeia de uma execução com Ed25519 para que um verificador externo possa provar que o histórico não foi alterado a partir de uma chave conhecida
Superfície de painel HITL	Botões confirmar/reconciliar/completar com paridade de auditoria com o CLI

Extensão de Segurança

Duas extensões de segurança aditivas ficam sobre o substrato de recuperação e checkpoint. Elas não alteram retomada, replay ou o caminho de revalidação existente em tempo de falha.

Status: especificado e testado, não enviado (issue #1030). Os módulos abaixo estão completos e passam em seus testes, mas nada no mecanismo ou em qualquer costura os invoca ainda (CONTINUUM revalida apenas em falha/retomada). Conectá-los é uma decisão de roadmap; leia o presente abaixo como o design, não o comportamento enviado.

Loop de Planejamento Seguro: observações carregam proveniência e são verificadas por dois sinais independentes (verified / unverified / contested). Um ramo de plano condicionado a uma observação não verificada ou contestada é elevado para REQUIRES_REVIEW. Decisões são anexadas ao registro como eventos PERCEPTION_OBSERVED e BRANCH_RESOLVED.
Revalidação Periódica: reutiliza o mecanismo de recuperação em um intervalo de passos (padrão 25) e na troca de aplicativo, para que desvios de ambiente no meio da execução sejam capturados dentro de um ciclo em vez de apenas na próxima falha.

Veja docs/PROBLEM.md, docs/RESULTS.md e STATUS.md.

Verificação Empírica

CONTINUUM é verificado contra agentes LLM reais, limites de protocolo ao vivo e falhas de processo difíceis, não apenas testes unitários simulados.

Agentes reais: lotes de faturamento do Claude Code em múltiplas sessões com SIGKILL no meio da execução, pontuados 7/7 em mecânica; sessões retomadas consultaram continuum_resume, rotearam efeitos colaterais através do registro de duas fases, recusaram duplicar escritas verificadas e respeitaram request_human. Testes ao vivo revelaram lacunas de deduplicação por desvio de prompt, fechadas por normalização de caminho canônico e fallback baseado em token em ActionLedger.claim().
Clientes de terceiros: Gemini CLI e Kilo Code conectados via stdio JSON-RPC contra o armazenamento SQLite ao vivo, validando coexistência multi-agente e isolamento de autorização.
Conformidade de protocolo: conduzido de ponta a ponta com @modelcontextprotocol/inspector --cli através de mortes de processo; ferramentas de mutação negam por padrão atrás de CONTINUUM_MCP_MUTATING_CLIENTS; reivindicações externas degradam para REQUIRES_REVIEW (safe: false).
Autocura: servidores mortos à força se recuperam de sidecars órfãos de SQLite -wal/-shm via limpeza de tentativa única na inicialização.
Escala: aproximadamente 3680 testes coletados (~3.680 passando; ~0 pulados; outros resultados variam por ambiente) em Python 3.11, 3.12 e 3.13 (unitários, hypothesis baseados em propriedades, concorrência, adversarial). CONTINUUM-Bench executa cinco cenários de falha mais um cenário dedicado de desvio de argumento, medindo 0 trabalho duplicado e 0 efeitos colaterais duplicados para CONTINUUM contra duplicação total para replay ingênuo; uma suíte separada de 14 cenários de correção de recuperação (continuum.benchmark.phase6) codifica os pontos de falha do levantamento de execução durável como asserções executáveis, e uma suíte de injeção de risco com 7 falhas (benchmarks/fault_injection/) avalia o tratamento de falhas.
Auditoria adversarial: toda a superfície MCP foi auditada sobre o protocolo ao vivo; três defeitos foram encontrados e corrigidos. Método e etapas de reprodução em test.md.

Benchmark de escala de horizonte (execuções reais, sem números inventados)

Gerado: 2026-09-30T11:03:24.403017 Cenários de horizonte: 5 Passados: 4 Falhados: 1

Precisão: 0.8 Escalação desnecessária: 0.2 Precisão de reparo: 0.8 Efeitos colaterais duplicados: 0 Trabalho duplicado: 0.0 Compressão: 0.138

Cenário	Ciclos	Anos	Correto	Real	Precisão
horizon_steady_progress_year	141	2.3	resume	resume	1.0
horizon_quarterly_drift_year	141	2.3	repair	request_human	0.0
horizon_budget_exhaustion_year	141	2.3	request_human	request_human	1.0
horizon_compaction_stress_year	177	2.87	resume	resume	1.0
horizon_abort_condition_year	141	2.3	abort	abort	1.0

Injeção de falhas: 7 cenários, detecção 1.0, inseguro 0.0

Integração MCP

CONTINUUM inclui um servidor MCP para que um agente possa registrar progresso, fazer checkpoint e rotear efeitos colaterais externos através do registro sem incorporar a biblioteca:

uv pip install -e ".[mcp]"
CONTINUUM_MCP_MUTATING_CLIENTS=your-client-name continuum-mcp

No Windows, a forma com prefixo de env não tem equivalente no PowerShell, então defina a variável primeiro:

uv pip install -e ".[mcp]"
$env:CONTINUUM_MCP_MUTATING_CLIENTS = "your-client-name"
continuum-mcp

Treze ferramentas via stdio. Três são somente leitura (continuum_validate, continuum_resume, continuum_list_actions); dez mutam. Efeitos colaterais são de duas fases (reivindicar, executar, completar), e ferramentas de mutação negam por padrão atrás de uma lista de permissões. Estado relatado pelo agente é registrado com proveniência Origin.EXTERNAL_AGENT e marcado REQUIRES_REVIEW.

Detalhes de verificação, incluindo recuperação de falha na inicialização e o teste de ponta a ponta do Claude Code, estão em references/mcp.md. Se um servidor registrado relatar CONNECTION_CLOSED, a causa é quase sempre resolução de PATH em vez do próprio servidor: docs/api/mcp.md tem o diagnóstico e dois remédios.

Integração de Framework

Nove adaptadores são enviados em src/continuum/adapters/ (uma fachada em processo mais oito integrações), todos instaláveis opcionalmente para que o núcleo permaneça apenas com a biblioteca padrão:

Adaptador	Classe	Notas
Agente Python genérico	`GenericAgentAdapter`	Fachada em processo; escreve estado confiável (`Origin.DETERMINISTIC`).
Sandbox de sistema de arquivos	`FilesystemSandboxAdapter`	Sandbox de diretório local, sem serviço externo, padrão para docs e CI.
Python em processo	`PythonInProcAdapter`	Executa Python em um diretório de trabalho temporário, registra via ledger.
Contêiner	`ContainerAdapter`	Suportado por Docker, pulo protegido quando `docker` está ausente.
Navegador	`BrowserAdapter`	Suportado por Playwright, pulo protegido quando não instalado.
Kubernetes	`KubernetesAdapter`	Suportado por `kubectl`, pulo protegido quando não configurado.
OpenAI Agents SDK	`OpenAIAgentAdapter`	Experimental. Ganchos `ToolContext` / `RunHooks`; `openai-agents` opcional.
LangGraph	`LangGraphAgentAdapter`	Experimental. Envolve um `StateGraph`; `langgraph` opcional.
LangChain	`LangChainAgentAdapter`	Experimental. Insere `checkpoint_node` em um pipeline LCEL `Runnable` e no loop de chamada de ferramentas `create_agent`; `langchain` opcional.

Cada adaptador registra progresso através do ledger e roteia efeitos externos através do protocolo de interceptação/completude de duas fases. Todos os três adaptadores de framework têm testes de integração de ponta a ponta e foram conduzidos contra um modelo OpenRouter ao vivo, onde as execuções revelaram e depois fecharam uma lacuna de deduplicação por desvio de argumento do LLM e dois bugs do adaptador OpenAI, incluindo uma prova de falha dura ao vivo (os._exit(137) no meio de efeito colateral) por adaptador. Uso completo, resultados de modelo ao vivo e exemplos executáveis para cada adaptador estão em references/adapters.md.

Aplicativos LangGraph de produção também podem manter sua API de persistência nativa: make_continuum_checkpointer(storage) implementa o BaseCheckpointSaver do LangGraph sobre o armazenamento do CONTINUUM, para que cada put caia no mesmo log de eventos encadeado por hash e marcado com proveniência (veja references/adapters.md).

Três frameworks de produção adicionais são cobertos por superfícies de gancho finas e sem SDK em adapters/thin.py:

Framework	Superfície de interceptação	Ponto de entrada
CrewAI	ganchos globais antes/depois de chamadas de ferramentas	`install_crewai_hooks(storage, run_id)`
AutoGen core	`FunctionTool.run_json` envolvido no lugar	`wrap_autogen_tool(tool, storage, run_id)`
Pydantic AI	capacidade de ganchos assíncronos	`Agent(capabilities=[wrap_pydantic_ai_hooks(storage, run_id)])`

Para stacks que nenhum desses alcança: continuum gateway impõe reivindicações em HTTP de saída de qualquer idioma, continuum.otel.make_span_processor(storage) transforma spans de ferramentas OpenTelemetry existentes em evidência, e continuum serve expõe as mesmas operações que as ferramentas MCP sobre um protocolo de fio JSON agnóstico de idioma (stdio, ou HTTP via --transport http com autenticação CONTINUUM_SERVE_TOKEN).

Retomando execuções relatadas por agente ou MCP

Estado relatado via MCP, ou através do adaptador OpenAI, carrega proveniência Origin.EXTERNAL_AGENT e resolve para request_human até ser confirmado. Execuções LangGraph e LangChain usam Origin.DETERMINISTIC e retomam diretamente. Para limpar a revisão e retomar:

continuum confirm <run_id>   # records REVIEW_CONFIRMED, then re-assesses
continuum resume <run_id>    # now reports RESUME

Via MCP, o equivalente é a ferramenta continuum_confirm seguida por continuum_resume. Confirmação é um evento único, atestado por humano: a saída de emergência para a segurança de autocertificação, para que uma execução conduzida externamente nunca fique permanentemente travada.

Conceitos Centrais

A referência profunda para cada conceito está em references/concepts.md.

Semantic Checkpoints - uma representação compacta e versionada do que o agente precisa para continuar.
Validação de Estado - cada componente verificado de forma independente; obsolescência se propaga pelo grafo de dependências.
Registro de Ações Idempotente - efeitos colaterais externos rastreados e deduplicados; resultados incertos geram exceção em vez de tentativas silenciosas.
Modos de Recuperação - RESUME, REPAIR_AND_RESUME, ROLLBACK, WAIT, REQUEST_HUMAN, ABORT (mais REPLAN).
Contrato de Recuperação - uma próxima ação determinística, selada por integridade e controlada.

Arquitetura

CONTINUUM é organizado em torno de um invariante: todo fato carrega sua origem, e confiança é conquistada, nunca presumida. Por que isso importa para uma startup: um agente que roda por semanas não deve perder trabalho quando seu contexto é perdido, e não deve desperdiçar tokens, custo ou disparar uma ferramenta duas vezes.

Sistema em resumo: adaptador universal, um log, qualquer harness

Qualquer harness se conecta ao mesmo log encadeado por hash. A mesma execução pode ser escrita pelo Claude Code, retomada pelo LangGraph, inspecionada pela CLI e aprovada no dashboard. Nenhuma cooperação de framework é necessária.

  Claude Code ─┐
  Gemini CLI ──┤
  Codex ───────┤
  LangGraph ───┼── 5 seams ──►  One durable log  ──►  Recovery + Dashboard + CLI
  LangChain ───┤                (hash chained,        (sealed contract,
  OpenAI SDK ──┤                 provenance tagged,     verify, health,
  CrewAI ──────┤                 exactly once)          family)
  Any HTTP ────┤
  Any OTel app ┘

  Seams: 1 In-process  2 MCP  3 CLI hooks  4 Gateway  5 OTel

As três garantias (a demo prova cada uma)

Sem autocertificação. O estado relatado pelo agente é EXTERNAL_AGENT e degrada para REQUIRES_REVIEW até que um humano REVIEW_CONFIRMED. Apenas escritores confiáveis produzem estado DETERMINISTIC.
Efeitos colaterais exigem reivindicações. Todo efeito externo é reivindicado em um registro idempotente antes de disparar. Efeitos não reivindicados são bloqueados na fronteira, duplicatas são recusadas, resultados incertos geram exceção para reconciliação.
Recuperação verifica contra a realidade. A retomada verifica digests de arquivos, versões de dependências e identidade do modelo antes de declarar segurança. Obsolescência se propaga dependency -> evidence -> finding -> decision mais PlanStep.depends_on para que apenas etapas afetadas sejam reparadas.

Cinco pontos de integração

Ponto	Como conectar	O que oferece
1 Em processo	`GenericAgentAdapter.intercept_action(...)` e `wrap_tool(key_fn=...)` em LangChain, LangGraph, OpenAI Agents SDK	Frameworks Python, escritas confiáveis
2 Servidor MCP	`continuum-mcp` 13 ferramentas via stdio (`continuum_record_progress`, `continuum_intercept_action`, `continuum_complete_action`, etc.)	Qualquer cliente compatível com MCP, 3 somente leitura + 10 mutáveis, allowlist `CONTINUUM_MCP_MUTATING_CLIENTS`
3 Hooks de ciclo de vida da CLI	`continuum hooks install claude-code --with-gate` também `gemini` e `codex`	CLIs de codificação: `SessionStart briefing`, `PostToolUse observe`, `PreToolUse gate`; sem necessidade de CLAUDE.md
4 Gateway HTTP de imposição	`continuum gateway --port 8765` com `.continuum/gateway.json`	Qualquer linguagem, qualquer HTTP de saída deve ter uma reivindicação, o gateway liquida a partir do código de status real
5 Ponte OpenTelemetry	`make_span_processor(storage)`	Qualquer aplicativo rastreado, spans se tornam evidência `TOOL_COMPLETED`

Superfícies de hook finas para CrewAI, AutoGen, Pydantic AI vivem em adapters/thin.py sem exigir SDK.

Pipeline de imposição: por que nenhuma duplicata e nenhuma chamada inválida

O gate para observar o pipeline fecha a lacuna na fronteira do harness. Isso é o que economiza tokens e custo e bloqueia chamadas de ferramenta inválidas.

PreToolUse hook                    PostToolUse hook
    |                                    |
    v                                    v
continuum gate                    continuum observe
    |                                    |
    |-- no claim? DENY (exit 2)          |-- TOOL_COMPLETED event:
    |   + instructions to claim          |     path, bytes, sha256 on disk now
    |                                    |
    |-- live claim? ALLOW                |-- disk checked status:
    |                                    |     verified / changed / missing
    v
agent performs effect
    |
    v
continuum_complete_action  (settled from reality, not from report)
    |
    v
ledger marked COMPLETED: next replay returns cached result, not a second fire

Host desconhecido é negado com falha fechada, não um relay aberto. Shell Bash/curl é o ponto cego documentado da v1.

Árvore de decisão de recuperação: semanas até concluir, correto e exato

O motor assume o sinal mais cauteloso, então a segurança nunca perde para a conveniência.

RESUME < REPAIR_AND_RESUME < REPLAN < WAIT < REQUEST_HUMAN < ROLLBACK < ABORT

Cada continuum resume retorna um contrato selado com: status de recuperação e safe, componentes verificados/invalidados, human_steps executável (shell exato para rodar), observações pós-checkpoint com disco verificado, pinning de drift e agregação de família para multi-agente continuum tree. Briefing continuum briefing injeta esse contrato em cada novo claude SessionStart, então dizer hi depois de matar o terminal retoma do último prefixo bom.

Por que isso economiza tokens, custo e chamadas inválidas

Tokens: Checkpoint semântico armazena Goal + Plan + Progress, não um despejo de transcrição. O briefing serve apenas estado verificado mais um resumo de raciocínio com limite de 4096, não a cauda de erros que o autocondicionamento mostra degradar a próxima sessão. Retry informado recovery/summary.py injeta um resumo criado pelo motor, não histórico bruto.
Custo: Registro action_index recusa efeitos colaterais duplicados mesmo sob drift de argumentos como caminhos relativos vs absolutos (chave estável invoice:INV-001), então a mesma API não é paga duas vezes após uma retomada. Orçamentos budgets.py limitam tempestades de retry no momento da reivindicação. continuum benchmark imprime 0 duplicates para continuum vs 50 para ingênuo.
Chamadas inválidas: Gate e gateway e replayguard langgraph_protected_node bloqueiam chamadas de ferramenta não reivindicadas ou repetidas antes de disparar. Pinning pinning.py revela drift de prompt ou ferramenta na retomada.

Arquitetura de armazenamento

Schema v6. SQLite é primário, Postgres é verificado por CI. Um log, muitas projeções.

Tabela	Propósito
`events`	Log somente anexação encadeado por hash (55 tipos de eventos na v0.2)
`runs`	Metadados de execução com `parent_run_id` para multi-agente
`versions`	Snapshots de SemanticState por checkpoint
`checkpoints`	Registros de checkpoint selados com âncoras `RECOVERY`
`action_index`	Projeção de idempotência entre execuções (schema v3+): leituras indexadas, não varreduras completas
`events_archive`	Armazenamento de prefixo compactado (schema v5+): `continuum compact` limita o log ativo por semanas
`lg_checkpoints` / `lg_writes`	Persistência nativa LangGraph (schema v4+): `make_continuum_checkpointer(storage)`

Mapa de módulos: uma biblioteca, muitas superfícies

CONTINUUM é uma biblioteca (src/continuum, 148 módulos) mais uma grande suíte de testes (210 arquivos de teste, ~3680 testes). Todos os módulos anexam e reproduzem um log de eventos encadeado por hash:

Módulo	Papel
`events.py`	Log de eventos somente anexação encadeado por hash e `verify() trusted_through`
`state/`	Projeção `project()`, validação, extração: propagação de obsolescência
`storage/`	`SQLiteStorage` v6, `postgres.py`, `migrations.py`, `actionindex.py`
`actions/`	Registro idempotente `claim/complete/reconcile`, chave `idempotency.py` + canonicalização + fallback de token, rastreamento de concessão consumida `GRANT_DENIED`
`checkpoint/`	Checkpoints orientados por política `manager.py` `policy.py` com âncoras `RECOVERY` e `prune`
`recovery/`	Motor, planejador, contrato selado `contract.py`, `guidance` `human_steps`, `observations` com disco verificado, rollup `family`, semântica `fork`, retry informado `summary`
`gate.py`	Imposição pré-uso de ferramenta: permitir ou negar contra reivindicações do registro
`gateway.py`	Proxy HTTP de imposição: reivindique antes de disparar para solicitações de saída
`replayguard.py`	Guarda portátil: `evaluate, protected_call, langgraph_protected_node`: fecha o risco de replay ACRFence
`hooks.py` `clienthooks.py`	Hooks de checkpoint compartilhados e perfis de instalador `claude-code gemini codex`
`budgets.py`	Registro de orçamento de retry e avaliação por tipo de ação
`pinning.py`	Normalização de pinning de versão e detecção de drift na retomada
`replay_similarity.py`	Backends de similaridade semântica exato/nebuloso/embedding para replay vs fork
`reconcilers.py`	Registro de probes `.continuum/reconcilers.json` para liquidação automática
`adapters/`	9 adaptadores de classe + hooks finos `thin.py` CrewAI AutoGen Pydantic AI + store LangGraph
`mcp/`	13 ferramentas stdio mais authz `authz.py` autenticação por token, allowlist, token de confirmação
`serve/`	Sidecar stdio JSON wire + HTTP `CONTINUUM_SERVE_TOKEN`
`dashboard/`	Dashboard web `app.py` `hitl.py` com botões HITL confirmar/reconciliar/completar, aviso de confiança de prefixo, pins
`cli/`	54 comandos argparse, códigos de saída como veredito: `runs, start, inspect, resume, verify, health, tree, benchmark, attest, lineage-issue, lineage-verify, dashboard`
`otel.py`	Ponte de processador de spans OpenTelemetry
`benchmark/`	Harness CONTINUUM-Bench: 5 cenários de crash + drift de argumentos + suíte de recuperação de 14 cenários + injeção de 7 riscos de falha

Limitações honestas

O gate não vê dentro de comandos shell (Bash/curl contornam reivindicações de ferramentas estruturadas)
Backend Postgres é testado por CI, mas não testado em batalha em produção
Um nível de hierarquia multi-agente na v1
Offloading de payloads grandes (#254) ainda não implementado
Benchmark de escala de semanas com tabela de custo de tokens chega no board #550 (#568 a #570)

Referência completa em references/architecture.md. E o plano de meses que se constrói sobre isso (grafo causal de proveniência, ressurreição de autoridade, admissibilidade, vivacidade) está fixado no board #550 com 20 sub-issues #551 a #570.

API e CLI

Superfície Python (EventType, Run, SQLiteStorage, diff_states, project) e a API de adaptadores são documentadas com exemplos executáveis em references/api.md. A CLI é a mesma superfície em forma de shell:

continuum runs                                   # list runs
continuum inspect <run_id>                       # semantic state
continuum validate <run_id> --env dataset=v4     # validate, read-only
continuum resume <run_id> --env dataset=v4       # recovery decision + contract + next steps
continuum checkpoint <run_id>                    # force a checkpoint, mutates
continuum actions <run_id>                       # external side effects
continuum reconcile <run_id>                     # settle uncertain effects with probes
continuum complete <run_id>                      # close a run as done, from the keyboard
continuum verify <run_id>                        # re-audit the event hash chain
continuum budget <run_id>                        # retry-budget usage per action type
continuum compact <run_id>                       # archive pre-anchor log prefix
continuum tree <parent_run_id>                   # show parent + children with recovery states
continuum attest <run_id> --key signer.pem       # sign the chain head for an external verifier

Todo o wiring é do lado do host; a cooperação do modelo é opcional:

continuum hooks install claude-code --with-gate   # coding CLIs: evidence, briefing, gate
continuum gateway --port 8765                     # enforcing HTTP proxy for everything else
provider.add_span_processor(continuum.otel.make_span_processor(storage))  # OTel to evidence
continuum-mcp                                     # anything MCP-capable: the twelve-tool server
continuum briefing                                # session-start context injection
continuum budget <run_id>                         # retry-budget usage report
continuum tree <parent_run_id>                    # multi-agent hierarchy view

Registros opcionais vivem ao lado do seu código e são dados, não código: .continuum/gate.json (ferramentas de efeitos colaterais + templates de chave estável), .continuum/reconcilers.json (probes que verificam sistemas externos), .continuum/gateway.json (rotas upstream).

A maioria dos comandos aceita --json global antes do subcomando (ex.: continuum --json resume RUN), e comandos somente leitura nunca escrevem, então são seguros contra um banco de dados ativo enquanto um agente está em execução. As duas exceções são somente auditoria e disparam apenas para uma execução já estacionada: resume registra o resultado da entrega do webhook quando o veredito é REQUEST_HUMAN e um endpoint está inscrito, e watch registra uma inversão de veredito de vivacidade; nenhum anexa projeções ao estado ou move o código de saída. Códigos de saída são um contrato de segurança (apenas uma execução verificada como segura sai com 0). Lista completa de comandos, tabela de códigos de saída e saída de diff de estado em references/cli.md.

Roadmap

Fase	Componente	Status
1-11	Modelos de dados, estado semântico, persistência, checkpointing, validação, registro de ações, motor de recuperação, CLI, exemplos de recuperação de crash, snapshots/diffs de ambiente, adaptadores de framework	Completo
12	Suíte de benchmark (CONTINUUM-Bench)	Completo (harness mínimo)
13	API em nuvem (FastAPI + PostgreSQL)	Parcial: o backend de armazenamento PostgreSQL e o transporte sidecar HTTP (`continuum serve --transport http`) estão lançados e testados por CI; o serviço multi-tenant hospedado não foi iniciado
14	Dashboard	Completo (`continuum dashboard`)
15+	Durabilidade imposta: hooks de observação, gate, briefing de sessão, probes de reconciliação, gateway de imposição, ponte OTel, índice de ações, orientação executável, instaladores multi-cliente, detecção de replay semântico, pinning de versão, orçamentos de retry, compactação de log, superfície HITL, semântica de fork, retry informado, agregação multi-agente	Completo (veja issue #213)
Próximo	Plano de durabilidade em escala de meses: planos ancorados em marcos (#312), memória estruturada de tentativas (#313), rewind atômico de estado duplo (#292), benchmark público de correção de recuperação (#293)	Planejado (especificação de rascunho em docs/UPGRADE_SPEC.md); notificações webhook-out (#305) lançadas

Além do plano original: o servidor MCP, camadas de autorização MCP e autenticação de chamador, proveniência e anti-autocertificação, arquivos da comunidade, versionamento de schema com migrações para frente, um contexto de recuperação limitado, rastreamento de concessão consumida, atestação de cadeia de eventos Ed25519, o checkpointer nativo LangGraph e artefatos wheel em cada push para main estão lançados. Veja STATUS.md para a divisão verificado-vs-acreditado e bugs de correção em aberto.

O que CONTINUUM Não É

Isto não	Isto sim
Um LLM	Uma camada de confiabilidade para agentes que usam LLMs
Um framework de agentes	Uma camada de recuperação que se conecta a qualquer framework
Um banco de dados vetorial	Estado semântico estruturado, não embeddings
Um sistema RAG	Checkpoints verificados, não memória aumentada por recuperação
Um motor de workflow	Uma camada de recuperação, não um orquestrador

A abstração central: semantic state + environment validation + action reconciliation = safe recovery.

O veredito é consultivo, não imposto

CONTINUUM diz a verdade sobre uma execução. Ele não interrompe seu processo quando a resposta é indesejada. RecoveryDecision.permits() relata o que o contrato permite; nada na biblioteca intervém se um chamador ignorar um False e agir mesmo assim. Um worker que chama CheckpointManager.restore diretamente pode continuar após um veredito REQUEST_HUMAN, porque nunca perguntou ao motor se deveria.

Este é um contrato deliberado para uma biblioteca: forçar a aplicação dentro de uma chamada que o chamador fez para inspecionar um veredito surpreenderia os chamadores que legitimamente querem lê-lo e depois sobrescrevê-lo.

A aplicação existe, mas como pontos de integração separados que você opta por ativar. Nenhum é habilitado por um pip install continuum-agent simples:

Ponto de integração	Como habilitar
Portão do host	`continuum gate`
Gateway HTTP	`continuum gateway`
Proteção de replay para chamadas de framework	`continuum.replayguard` em processo
Hooks de observação	`continuum hooks install`

A única aplicação que já vem habilitada é o código de saída da CLI. continuum resume sai com código não zero, a menos que a execução seja verificada como segura (RESUME), então continuum resume "$RUN" && ./start-agent.sh não pode iniciar sobre estado obsoleto. Todos os outros modos mapeiam para um código não zero distinto, e um modo que ninguém classificou cai em UNSAFE em vez de OK.

Se você quiser que o veredito seja aplicado, conecte um ponto de integração ou condicione seu pipeline ao código de saída. Não presuma que a biblioteca está supervisionando o processo.

Trabalhos relacionados

CONTINUUM está na interseção de execução durável, rastreamento idempotente de efeitos colaterais e recuperação de falhas para agentes LLM. Os vizinhos mais próximos são contratos de retomada verificados por máquina (Khan 2026), processamento transacional de agentes com admissão restrita por restrições (Mnemosyne 2026), análise de ataques de checkpoint-rollback (ACRFence 2026) e defesa contra injeção de prompt em nível de design (CaMeL 2025). A lista anotada completa, fundamentos e auditoria de citações estão em references/related-work.md.

Status e limitações

Testado: 3.680 coletados, a maioria passando; pulos exatos variam em uma execução completa na auditoria de 2026-08-24 desta árvore; CI aplica a suíte em Python 3.11, 3.12 e 3.13, e as contagens variam por plataforma e serviços opcionais como Postgres (veja STATUS.md). A superfície MCP também foi auditada de forma adversarial sobre o protocolo ao vivo; veja test.md.
No PyPI como continuum-agent 0.1.2 (pip install continuum-agent; o clone ainda funciona via pip install . veja Quick Start).
A autenticação do chamador MCP é opcional por implantação. Quando CONTINUUM_MCP_TOKEN está definido, o servidor recusa toda ferramenta de mutação, a menos que o chamador apresente esse segredo compartilhado no initialize do handshake _meta.authToken; segredos por chamador estão disponíveis via CONTINUUM_MCP_CLIENT_TOKENS (pares name:secret). Sem nenhum token configurado, a autorização é apenas pela identidade declarada (o padrão histórico, preservado para uso local de usuário único).
Confirmar estado auto-relatado via MCP requer um segredo separado. continuum_confirm recusa todo chamador até que o operador defina CONTINUUM_MCP_CONFIRM_TOKEN, porque um agente autorizado a registrar progresso não deve também ser capaz de confirmá-lo. O caminho padrão permanece conduzido por humanos: execute continuum confirm <run_id> no host.
Componentes não construídos: Cloud API (Fase 13).
Lacuna na aplicação de comandos shell: o portão aplica reivindicações para chamadas de ferramentas estruturadas, mas não pode ver dentro de comandos Bash/curl. Documentado como recusa de escopo v1.
Adaptadores de framework permanecem experimentais. Todos os três adaptadores de framework agora carregam provas de retomada suave e falha dura com modelo ao vivo (OpenRouter, gpt-4o-mini), incluindo o contrato de falha que bloqueia a retomada em um efeito colateral incerto, e agora têm testes de verificação de falha e retomada alcançando paridade com a fachada genérica (Refs #285). Prefira GenericAgentAdapter para recuperação em produção.
Execuções de agente/MCP precisam de uma confirmação explícita antes da retomada automática. Estado relatado externamente é REQUIRES_REVIEW, então continuum resume retorna request_human até que um humano confirme. Por design, não é um bug; veja Framework Integration.
Série de testes de autonomia e2e (issue #6): três execuções completas do Claude Code pontuaram 7/7 em mecânica com comportamento de recuperação não solicitado observado. Mais iterações em diversos estilos de prompt permanecem em aberto.

Sobre

No início de 2026, vi agentes de longa duração falharem na recuperação, não no raciocínio. Checkpoints eram tratados como prova para continuar, não como evidência a verificar. Pesquisando Temporal, LangGraph, ACRFence 2603.20625 e self conditioning 2509.09677, encontrei a lacuna: um substrato de verificação portátil que pergunta, dado o estado no tempo T e o mundo como está agora, ainda é seguro continuar.

Em três semanas, construí CONTINUUM a partir de um invariante: todo fato carrega sua origem. O resultado é um log encadeado por hash com verify(), um ledger com deduplicação estável de chaves, um portão e um gateway que bloqueiam efeitos não reivindicados, e um motor de recuperação que sela um contrato. Cinco pontos de integração expõem o mesmo log ao Claude Code, LangGraph, LangChain, OpenAI, HTTP e OpenTelemetry. Validado com mortes reais e ~3680 testes, imprime 0 duplicates onde o replay ingênuo imprime 50.

CONTINUUM foi criado por Anandhu P Shaji (@Cyrax321 · LinkedIn) e é mantido pelo criador original. É open source sob a licença Apache-2.0. Contribuições da comunidade são bem-vindas via CONTRIBUTING.md e são creditadas em AUTHORS.md e graphs/contributors.

Contribuindo

Este projeto é open source sob Apache 2.0 e deliberadamente construído para ser estendido: por pesquisadores validando a semântica de recuperação, por engenheiros portando o ledger ou o servidor MCP para outros frameworks ou linguagens, e por qualquer pessoa transformando o roadmap planejado em realidade. Um bom lugar para começar é o rótulo good first issue no issue tracker, ou os bugs de correção abertos listados em STATUS.md.

Abra uma issue antes de enviar PRs grandes. Veja CONTRIBUTING.md para o guia completo de contribuição, incluindo o Code of Conduct.

Contribuidores

Agradecemos aos nossos contribuidores da comunidade, ordenados por contribuições: @Adhi1-2, @abyyxhek, @Amiirhosseini, @yuki-fuyutsuki, @vjymisal0, @adity982, @dchaudhari7177, @tasodoufu, @anya-research, @lesbass, @Parthipashok04, @Samearth17, @stoppo22, @timothyanderson096-ocdealcheck, @unmoha, @aastha-m22, @as950118, @asarakhatun17-lgtm, @challenge456, @gouthamkrishnak2003, @ItzSaurav, @mhaye9545, @Newer1107, @okestroHjJeong, @quangshuynh, @Rahul-pamula, @Shaisolaris, @VedantMadane, @zynx-real.

Patrocinador

Se CONTINUUM ajuda seus agentes a se recuperarem de forma confiável, considere patrocinar para apoiar a manutenção de longo prazo.

Torne-se um patrocinador: GitHub Sponsors, ou adicione um link personalizado FUNDING.yml se preferir outra plataforma.

Licença

Apache 2.0 - veja LICENSE.

Material de referência aprofundado:

references/install.md - pré-requisitos, níveis de instalação, mapa de pacotes, verificação
references/concepts.md - checkpoints semânticos, validação, ledger, modos de recuperação, contrato
references/architecture.md - modelo de dados, log de eventos, projeção, armazenamento, checkpointing, motor de recuperação, segurança
references/adapters.md - uso de adaptadores de framework e resultados de validação com modelo ao vivo
references/api.md - API Python e de adaptadores
references/cli.md - lista completa de comandos CLI, códigos de saída, diff de estado
references/mcp.md - status do servidor MCP, verificação, perguntas em aberto
references/bench.md - design do CONTINUUM-Bench
references/quickstart.md - instalação, exemplos, os scripts de prova
references/e2e.md - passo a passo do teste de autonomia de ponta a ponta
references/testing.md - layout e convenções da suíte de testes
references/related-work.md - trabalhos relacionados anotados e auditoria de citações

Links rápidos

Issues para bugs/recursos
Discussions para propostas de design