> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/aprender/garantias/garantias-de-execucao.md).

# Garantias de execução

O que o skail promete sobre uma execução, o que não promete, e o que fica a cargo do seu código. Em uma tabela, para o arquiteto que precisa decidir.

## O que o skail garante

| Garantia                   | O que significa                                                                                                       | Mecanismo                                                                                 |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| Retomada                   | Uma execução interrompida (queda, restart, deploy, fim de espera) continua do último `await` concluído, sem recomeçar | Histórico por execução e replay da function                                               |
| Memoização de commands     | Um command que gravou o resultado não executa de novo naquela execução, em nenhuma retomada                           | Passo com argumentos e resultado no histórico; o replay devolve o gravado                 |
| Retry de commands          | Um command que lança exceção é reexecutado até `retryCount` vezes antes de a exceção chegar à function                | Reentrega da execução; `retryCount` do atributo (5 por padrão)                            |
| Retry de functions         | Uma function que lança exceção é reentregue até o seu `retryCount` (15 por padrão), sem repetir commands concluídos   | Reentrega; memoização                                                                     |
| Espera durável por tempo   | Um `Delay` sobrevive a qualquer interrupção da aplicação e acorda no prazo                                            | Agendamento no skail; hibernação                                                          |
| Entrega de evento          | Um fire com o mesmo nome e instance id de uma espera acorda essa espera, mesmo que chegue antes dela                  | Casamento nome e id no skail; um fire que chega antes é entregue quando a espera aparecer |
| Um dono por execução       | Duas instâncias da sua aplicação não processam a mesma execução ao mesmo tempo                                        | Garantido pelo skail na entrega                                                           |
| Isolamento por environment | Execuções, histórico e eventos de um environment não são visíveis de outro                                            | Namespace `tenant/environment` e chave por environment                                    |
| Rastreabilidade            | Cada passo de cada execução fica visível com argumentos, resultados e tempos                                          | Histórico da execução e telemetria no Monitor                                             |

## O que o skail não garante

| Não garantido                                           | Por quê                                                                                                                                                                         | O que fazer                                                                                                                                                                 |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Efeito externo exatamente uma vez                       | Se um command falha entre executar o efeito e gravar o resultado, a próxima tentativa executa o efeito de novo. A janela é pequena e inevitável em qualquer sistema distribuído | Chave de idempotência (id de negócio) em toda chamada externa. Ver [Como escrever commands idempotentes](/construir/escrever-fluxos/como-escrever-commands-idempotentes.md) |
| Distinção entre erro transitório e definitivo           | O runtime não classifica exceções; toda exceção gera nova tentativa                                                                                                             | Falha de negócio como resultado, não exceção                                                                                                                                |
| Compatibilidade automática entre versões de código      | Uma execução em andamento referencia a sequência de `await`s da versão em que começou                                                                                           | Versionar a function ou o workload antes de mudar o fluxo. Ver [Versionamento](/aprender/fundamentos/versionamento-de-codigo-com-execucoes-em-andamento.md)                 |
| Ordem de conclusão em `WhenAll`                         | As ramificações terminam em ordem não determinada                                                                                                                               | Ler resultados pela posição                                                                                                                                                 |
| Latência de retomada                                    | A retomada depende de haver uma instância da sua aplicação rodando com esse workload                                                                                            | Manter réplicas suficientes e observar o estado Na fila no Monitor                                                                                                          |
| Entrega de evento sem espera correspondente para sempre | Um fire que chega antes do `WaitForEvent` é entregue quando a espera aparecer, mas não conte com isso por tempo indeterminado                                                   | Dispare o evento depois do trigger da execução que vai esperar por ele                                                                                                      |
| Estado compartilhado entre execuções                    | Cada execução tem o próprio histórico; não há memória compartilhada nem lock distribuído exposto                                                                                | Estado compartilhado no seu banco, via commands                                                                                                                             |

## O que fica com o seu código

Determinismo da function (sem I/O, relógio ou aleatoriedade fora de commands). Idempotência do efeito externo. Prazo em toda espera. Versionamento ao mudar fluxos com execuções em andamento. Retry no chamador do trigger, que é a única etapa fora da durabilidade. Tamanho e conteúdo dos argumentos (o que trafega para o skail).

## Como isso se compara

Qualquer plataforma de execução durável (Durable Functions, Temporal) tem exatamente esta divisão: a plataforma garante retomada, memoização e retry; o efeito externo exatamente uma vez continua sendo idempotência do cliente. Quem já operou filas reconhece a lista e desconfia de quem promete mais.

## Próximos passos

[Falhas, retries e idempotência](/aprender/fundamentos/falhas-retries-e-idempotencia.md) detalha as duas primeiras linhas. [Limites e cotas](/aprender/garantias/limites-e-cotas.md) para os números. [Segurança](/aprender/garantias/seguranca.md) para isolamento e dados.