# Idea - Orquestrador Autônomo de Demandas SDD

## Rastreabilidade
- Orquestração: Orquestrador Autônomo de Demandas SDD
- Slug: orquestrador-autônomo-de-demandas-sdd
- Stage: idea
- Estado atual: recorded
- Origem: entrada humana inicial + classificação de risco (`00-risk-classification.md`, nível high).
- Próximo artefato: PRD em `02-prd.md`.

## Problema
O `pipeline.html` descreve "autônomo com checkpoints" como **destino** (§08) e nomeia a *cola* que precisa ser construída (§07): o **orquestrador durável** com portões, a **camada de memória**, o **artifact store local** e a **lógica de rastreabilidade**. Hoje o `sdd` entrega bem as etapas quando um humano dispara cada uma, mas faltam quatro elos para o fluxo andar sozinho:

1. **Ingestão**: nada observa uma fila/backlog para iniciar uma feature automaticamente quando uma demanda entra. O início é sempre manual (`sdd orchestration "..."`).
2. **Loop durável de planejamento**: não há uma máquina de estados que avance Idea → PRD → Tech Spec → Tasks → Refinamento sozinha, **persistindo o estado** e **pausando indefinidamente** nos portões humanos sem perder contexto (o calcanhar de Aquiles de quem improvisa, segundo §06).
3. **Espelhamento e aprovação externos**: os artefatos vivem só em `docs/<slug>/`; não há espelho dinâmico em Jira (estado/itens) e Confluence (páginas/whiteboards), nem aprovação por Slack — só CLI.
4. **Execução e revisão autônomas em paralelo**: existe base (`parallel.rs` planeja slots e analisa dependências; `execution.rs` captura snapshot/diff), mas não há orquestração de **múltiplos agentes em git worktrees isolados**, cada um ciente do contexto dos outros, com **loops de revisão → correção** até o verde, fechando em publicação + memória.

Sem esses elos, a autonomia fica presa na demo: um script comum estoura quando o PM leva três dias para aprovar o PRD, agentes brigam pelo mesmo arquivo na execução, e o conhecimento de cada ciclo se perde em vez de alimentar o próximo.

## Objetivo
Construir a *cola* que transforma o `sdd` de harness disparado por humano em **orquestrador autônomo dirigido por demanda**, sem quebrar o fluxo manual atual e respeitando a regra de ouro (a spec é o contrato; a rastreabilidade é o produto):

- Uma **fila de demandas** que, ao receber um item, inicia a orquestração e gera a etapa Idea automaticamente.
- Um **orquestrador durável** que avança as etapas de planejamento e **pausa nos checkpoints** (PRD, Tech Spec, Refinamento), persistindo estado e retomando ao receber o sinal de aprovação — **via Slack ou via CLI**, indistintamente.
- **Espelhamento por tipo de artefato**: documento no Confluence (página/whiteboard), estado/itens no Jira (épico, história, task, bug), código no repo provider — sempre com `docs/<slug>/` como fonte canônica de fallback e **links**, nunca duplicação.
- **Execução paralela autônoma** em **git worktrees** isolados (um por lane/task independente), com contexto compartilhado e ownership de arquivos, seguida de **revisão multidimensional** e **loops de correção** até passar nos critérios de aceite executáveis.
- **Fechamento do loop**: publicação da solução e consolidação de **memória** para os próximos agentes herdarem o contexto.
- Tudo **provider-neutral** (Codex, Claude, Gemini, opencode, Cursor) e **faseado** (§08): conquistar autonomia, não declará-la no dia um.

## Usuários
- **Operador/mantenedor do `sdd-layer`**: liga o modo autônomo, define políticas de gate, observa a esteira e intervém quando preciso.
- **Engenheiro do time**: coloca uma demanda na fila e a vê avançar até PR revisável, aprovando nos portões pelo Slack ou pelo terminal.
- **PM / Tech Lead**: aprova PRD/Tech Spec/Refinamento sem entrar no terminal, decidindo com evidência (link local + externo) no Slack/Jira.
- **Os próprios agentes** (Idea→Memory e os executores em worktree): precisam de estado durável, contexto compartilhado e memória para serem bons *neste* codebase.

## Critérios de sucesso
- Uma demanda que entra na fila dispara a orquestração e produz a etapa Idea sem ação humana.
- O orquestrador avança o planejamento sozinho e **pausa** em cada checkpoint, persistindo estado; ao aprovar (Slack ou CLI) ele **retoma exatamente de onde parou**, mesmo após reinício do processo.
- Cada artefato aprovado existe em `docs/<slug>/` (canônico) e, quando as integrações estiverem ligadas, é espelhado/linkado em Jira e Confluence sem conteúdo duplicado.
- A execução roda múltiplos agentes em worktrees isolados, sem conflito de arquivos, com revisão e ao menos um loop de correção exercitado, fechando com memória atualizada.
- O fluxo manual existente (`sdd init`, etapas individuais, `artifact`, `doctor`, TUI) continua funcionando e coberto por testes.
- Nenhum segredo vaza para artefatos ou logs; toda ação autônoma sensível tem worktree isolado, diff revisável e aprovação humana rastreável.
- Funciona em qualquer provider/harness suportado, com fallback Markdown quando faltar tool calling/MCP/browser.
