# Usando o modo Autopilot na CLI do GitHub Copilot

Dê Copilot CLI uma tarefa bem definida e deixe que execute a implementação, os testes e a iteração sem aguardar entrada após cada etapa.

Para obter uma visão geral de quando usar o modo Autopilot e o que considerar antes de entregar uma tarefa, consulte [Permitindo que GitHub Copilot trabalhe de forma autônoma](/pt/copilot/concepts/agent-capabilities/agent-powered-workflows-and-operations/autopilot).

## Iniciando ou alternando para o modo Autopilot

Você pode iniciar o modo Autopilot a partir de uma sessão interativa Copilot CLI .

1. No terminal, inicie a CLI:

   ```shell copy
   copilot
   ```

2. Pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> até que a linha de status mostre o modo piloto automático.

3. Se a CLI perguntar como lidar com permissões, escolha entre habilitar todas as permissões, usar aprovação manual para a sessão ou cancelar.

4. Insira um prompt específico que inclua o resultado e as verificações esperadas. Por exemplo:

   ```copilot
   Add pagination to the users API. Preserve the existing response
   fields, add tests for the first and final pages, and run the API
   test suite.
   ```

Você também pode iniciar ou voltar a focar o modo Autopilot com o comando de barra `/autopilot`:

```copilot
/autopilot Fix the failing API tests and verify the full test suite
```

Para sair do modo Autopilot, pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> para alternar para outro modo.

## Migrar de um plano para o modo autopilot

Para um trabalho complexo, crie e examine um plano antes de permitir a implementação autônoma.

1. Em uma sessão interativa, pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> até que a linha de status mostre o modo Plan.
2. Insira um prompt que descreve a alteração, as restrições e a validação necessária.
3. Examine o plano e peça Copilot para revisá-lo até que ele corresponda aos seus requisitos.
4. Selecione **Aceite o plano e continue no modo de execução do Autopilot**.
5. Se solicitado, escolha as permissões apropriadas para a tarefa.
6. Monitore a implementação e examine as alterações resultantes e a saída do teste.

Para iniciar uma sessão plan-then-Autopilot pela linha de comando, insira:

```shell copy
copilot --plan --mode autopilot
```

Esse comando passa do planejamento para o modo Autopilot automaticamente quando o plano estiver pronto. Ele não aguarda a aprovação interativa do plano. Para obter o comportamento exato e as opções compatíveis, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#plan-then-autopilot).

## Configurando permissões

Ao entrar no modo de piloto automático, se você ainda não concedeu Copilot todas as permissões, uma mensagem será exibida solicitando que você escolha entre três opções:

```text
1. Enable all permissions (recommended)
2. Use Manual Approval for this session
3. Cancel (Esc)
```

Você obterá os melhores resultados do modo Autopilot se habilitar todas as permissões. Se você escolher a aprovação manual, Copilot negará automaticamente todas as solicitações de ferramenta que exijam aprovação, o que pode impedi-la de concluir determinadas tarefas. Você pode mudar de ideia mais tarde e conceder permissões completas, durante uma sessão do Autopilot, usando o `/allow-all` comando (ou seu alias `/yolo`).

Antes de conceder permissões amplas a Copilot, considere usar um sandbox local ou executar a sessão em um sandbox na nuvem para limitar o que Copilot pode acessar.

Se você habilitar o isolamento local em sandbox ao usar o modo Autopilot, Copilot concluirá tudo o que conseguir realizar dentro da sandbox sem interrupção. No entanto, qualquer etapa que precise sair do sandbox — por exemplo, gravar em um arquivo fora do diretório de trabalho atual — é negada. Para obter mais informações sobre isolamento local em sandbox, consulte [Sobre o sandboxing local para GitHub Copilot](/pt/copilot/concepts/about-cloud-and-local-sandboxes).

## Comparando o modo Autopilot, `--allow-all` e `--no-ask-user`

Esses controles afetam aspectos separados de como Copilot CLI funciona:

* **O modo Autopilot** controla a continuidade. O agente pode trabalhar em etapas sucessivas que exigem interações adicionais com o modelo de IA sem esperar por outro prompt.
* **`--allow-all`**, e seu nome alternativo `--yolo`, controlam as aprovações. Eles permitem que o agente use todas as ferramentas, caminhos e URLs sem solicitar permissão, mas não permitem a continuação autônoma. No modo interativo, o agente ainda para quando precisa de direção adicional.
* **`--no-ask-user`** suprime perguntas de esclarecimento. O agente toma decisões em vez de solicitar entrada, mas não continua por meio de interações de modelo sucessivas, a menos que o modo Autopilot também esteja habilitado.

Durante uma sessão interativa, você pode habilitar todas as permissões com `/allow-all` ou `/yolo`.

> [!NOTE]
> Os comandos `/allow-all` e `/yolo` habilitam todas as permissões para a sessão atual. Inserir qualquer um dos comandos novamente não desabilita as permissões.

Para obter mais detalhes sobre as opções de comando disponíveis para permissões, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#command-line-options).

## Limitação do trabalho autônomo

Defina limites para impedir que uma tarefa continue por mais tempo ou consuma mais AI credits do que você espera.

* Use `--max-autopilot-continues=COUNT` para definir um limite máximo para mensagens de continuação automática.
* Utilize `--max-ai-credits=CREDITS` para definir um limite flexível AI credit para uso programático.
* Em uma sessão interativa, use `/limits` para inspecionar ou alterar o AI credit limite.

Para ver os padrões atuais e os valores aceitos, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#command-line-options). Para obter procedimentos sobre limites AI credit, consulte [Definindo um AI credit limite de sessão em GitHub Copilot CLI](/pt/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit).

## Parar e revisar o trabalho

1. Para interromper uma interação em execução, pressione <kbd>Esc</kbd> duas vezes.

2. Para impedir que o próximo prompt seja executado no modo Autopilot, pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> para selecionar outro modo.

3. Examine os arquivos que o agente alterou. Na CLI, você pode abrir a visualização de diff com:

   ```copilot
   /diff
   ```

4. Execute os testes, linters e verificações de segurança relevantes antes de confirmar ou enviar por push as alterações.

Para todos os controles de interrupção e revisão, consulte [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#global-shortcuts-in-the-interactive-interface).

## Escolhendo o modo para a próxima tarefa

Por padrão, o modo Autopilot é persistente: assim que Copilot determina que uma tarefa está concluída, Copilot CLI permanece no modo Autopilot, portanto, o próximo prompt que você inserir também é tratado no modo Autopilot. Você pode alternar de volta para o modo interativo padrão a qualquer momento pressionando <kbd>Shift</kbd>+<kbd>Tab</kbd>.

Se você preferir voltar Copilot CLI automaticamente para o modo interativo após a conclusão de cada tarefa, poderá desabilitar esse comportamento definindo `stayInAutopilot` como `false`. Você pode fazer isso de qualquer uma das seguintes maneiras:

* Durante uma sessão interativa, insira `/settings stayInAutopilot false`.
* Adicione `"stayInAutopilot": false` ao arquivo de configuração do usuário (`~/.copilot/settings.json`). Para obter mais informações, consulte [Diretório de configuração do GitHub Copilot CLI](/pt/copilot/reference/copilot-cli-reference/cli-config-dir-reference#user-settings-copilotsettingsjson).

Quando essa configuração é desabilitada, Copilot retorna automaticamente para o modo interativo padrão quando uma tarefa é concluída. Para executar outra tarefa no modo Autopilot, pressione <kbd>Shift</kbd>+<kbd>Tab</kbd> e percorra os modos disponíveis até entrar novamente no modo autopilot e, em seguida, insira o próximo prompt.

> [!NOTE]
> Essa configuração controla apenas em qual modo você está *após* a conclusão de uma tarefa. Isso não faz com que Copilot continue funcionando após decidir que a tarefa foi concluída. O Autopilot ainda para quando a tarefa é concluída, quando ocorre um problema, quando você pressiona <kbd>Ctrl</kbd>+<kbd>C</kbd> ou quando o limite de continuação é atingido.

## Executando o modo Autopilot programaticamente

Use o modo Autopilot programático para um script ou outro fluxo de trabalho não interativo em que a CLI deve continuar após o prompt inicial.

1. Decida quais permissões a tarefa requer.
2. Defina um limite de continuação ou um AI credit limite apropriado para a tarefa.
3. Execute o prompt com `-p` e `--autopilot`. Por exemplo:

   ```shell copy
   copilot --autopilot --yolo --max-autopilot-continues 10 -p "SEU TEXTO AQUI"
   ```

   Substitua `YOUR PROMPT HERE` por uma tarefa específica. Este exemplo concede todas as permissões e define o número máximo de continuações automáticas para `10`.

Para obter a lista completa de opções programáticas, consulte [referência programática do GitHub Copilot CLI](/pt/copilot/reference/copilot-cli-reference/cli-programmatic-reference) e [referência de comando da CLI GitHub Copilot](/pt/copilot/reference/copilot-cli-reference/cli-command-reference#command-line-options).