Intenção declarativa → contrato de execução determinístico → agente / harness

Decretum

Decretum transforma intenção estruturada em um contrato de execução determinístico para agentes e harnesses.

Decretum é um Compilador de Execução Declarativa neutro em relação ao domínio. Ele combina schemas, receitas, perfis, registros de provedores/integrações, descoberta, validação, política e resolução determinística para produzir um Contrato de Execução portátil.

A pesquisa de segurança é o domínio de referência do Decretum, não sua fronteira arquitetural. O mesmo modelo de compilador pode descrever engenharia de software, automação de infraestrutura, engenharia de dados, resposta a incidentes, experimentos científicos e outros trabalhos técnicos reproduzíveis.

Arquitetura

Decretum não é um runtime. Ele define o que pode ser executado e produz um contrato de execução portátil. Ele não executa trabalho, não gerencia a interação agente/pesquisador, não coleta evidências, não mantém achados nem gera relatórios.

Após a compilação, Decretum para. O contrato é passado para um harness externo ou runtime de agente.

Se a execução posteriormente precisar de uma nova capacidade ou de um requisito alterado, a solicitação retorna ao Decretum para validação, resolução e recompilação.

O modelo

Schema       = o que existe / fronteiras semânticas
Recipe       = o que deve ser feito
Profile      = características e preferências de execução
Registry     = implementações disponíveis
Resolver     = vinculação determinística de capacidades
Compiler     = geração de contrato portátil
Harness      = execução e interação reais
Store        = memória persistente de execução/pesquisa

A separação importante é:

                    DECRETUM
          Compilador de Execução Declarativa
                       |
       +---------------+---------------+
       |               |               |
    Schema           Recipe          Profile
   "o que"          "fazer"          "como"
       |               |               |
       +---------------+---------------+
                       |
                    Resolver
                       |
     capability + provider + integration
       + harness + readiness + policy
                       |
                       v
               Contrato de Execução
                       |
                       v
              Harness/Agente Externo
                       |
          +------------+------------+
          |            |            |
       execute      interact      persist
          |            |            |
          +------------+------------+
                       |
                    Store

Pacotes de domínio

O núcleo do compilador é neutro em relação ao domínio. Semânticas específicas de domínio residem em registros e schemas, e não em ramificações do compilador.

Exemplos:

• Pesquisa de segurança — malware, rede, forense, detecção e investigação em nuvem
• Engenharia de software — alterações de código-fonte, dependências, testes, builds e contêineres
• Infraestrutura — requisitos de VM, contêiner, rede e implantação
• Engenharia de dados — conjuntos de dados, transformações, validação e artefatos
• Experimentos científicos/técnicos — instrumentos, observações, análise e evidências

Um pacote de domínio contribui com capacidades, schemas, receitas, perfis e metadados de provedores. Ele não altera a semântica central do resolver/compilador.

Por que contratos estruturados em vez de especificações amplas em markdown?

Markdown é excelente para explicação. Não é uma interface de execução determinística.

Decretum separa:

intenção humana
    |
    v
schema estruturado + recipe + profile
    |
    v
resolução validada
    |
    v
contrato de execução portátil
    |
    v
execução por agente / harness

Isso dá aos agentes uma fronteira legível por máquina, mantendo as escolhas de implementação fora da receita.

Exemplo: engenharia de software

Uma tarefa de software pode usar o mesmo compilador:

apiVersion: decretum.dev/v1
kind: ExecutionRecipe
domain: software_engineering
id: build-user-service
name: Build User Service
version: "1.0"
objective: Build and validate a Python service.

capabilities:
  - source.read
  - source.modify
  - dependency.install
  - test.execute
  - artifact.build
  - container.build

profiles:
  infrastructure: local-dev
  language: python
  testing: pytest
  container: docker
  agent: coding-agent

completion:
  required:
    - tests_pass
    - artifact_built
    - container_built

A mesma intenção pode ser compilada com outro conjunto de preferências:

profiles:
  infrastructure: isolated-dev-vm
  testing: pytest
  container: podman
  agent: enterprise-coding-agent

A receita descreve intenção. O perfil expressa preferências. O registro de provedores determina o que está realmente disponível.

Exemplo de referência em pesquisa de segurança

id: suspicious-network-investigation
name: Suspicious Network Investigation
version: "1.0"
role: threat_researcher
objective: Determine whether the sample creates unexpected network activity.

capabilities:
  - process.observe
  - network.capture
  - artifact.collect

infrastructure_profile: isolated-linux-vm
instrumentation_profile: linux-network-observation
harness_profile: interactive-research

A receita não contém o ciclo de vida do Lima/Docker, implementação de MCP, prompts de agente ou código específico de runtime.

Fluxo de trabalho ponta a ponta

1. Defina a intenção estruturada.
2. Referencie capacidades canônicas.
3. Selecione perfis/preferências.
4. Valide a receita.
5. Descubra as superfícies de execução disponíveis.
6. Resolva capacidade → provedor → integração → harness.
7. Verifique prontidão e política.
8. Compile o Contrato de Execução.
9. Entregue o contrato ao harness externo.
10. O harness executa, interage e persiste seu estado.
11. Se os requisitos mudarem, retorne ao Decretum e compile um novo contrato.

Decretum não executa as etapas 9–10.

Evolução de capacidades

DISCOVER
   |
PROPOSE
   |
SEMANTIC REVIEW
   |
APPROVE
   |
CANONICAL CAPABILITY
   |
PROVIDER IMPLEMENTATIONS

A descoberta pode propor uma capacidade, mas não pode mutar silenciosamente a semântica canônica.

Início rápido

git clone https://github.com/Opposum0112/Decretum.git
cd Decretum
uv sync
decretum capabilities discover
decretum validate recipes/<recipe>.yaml
decretum resolve recipes/<recipe>.yaml
decretum compile recipes/<recipe>.yaml

Nada no caminho de validate/resolve/compile do Decretum executa o trabalho.

Cadeia de resolução

Capability
    |
Provider
    |
Integration
    |
Execution surface
    |
Harness compatibility
    |
Host/provider readiness
    |
Policy compatibility
    |
READY / BLOCKED

Fronteira arquitetural

Decretum deliberadamente não se torna: