> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/pt-br/apps-na-rome/bloom/issuing.md).

# Emitindo

Bloom permite que você emita um **ativo do mundo real com permissão** como um contrato Solidity comum em uma cadeia Rome, e administrá-lo a partir de um console por ativo. O ativo pode ser acessado tanto por carteiras EVM quanto por carteiras Solana, mas **a emissão é apenas EVM** — uma carteira Solana mantém ativos; ela não os cria. Este guia cobre o console do emissor, o assistente de criação, a porta de entrada de login do console e cada uma das seis abas de administração.

> **Você não entrega ao Bloom nenhum documento ou dado pessoal, e seu investidor também não.** Bloom registra *resultado* sua decisão de conformidade; a cadeia registra um booleano por endereço. Seu processo de KYC/AML — seus fornecedores, seus arquivos, sua retenção — permanece inteiramente no seu próprio sistema. O modelo completo está em [COMPLIANCE.md](https://docs.rome.builders/pt-br/apps-na-rome/bloom/compliance.md); este guia aponta para ele em vez de repetir tudo.

***

## O que você pode fazer

Como administrador de um ativo, tudo abaixo é algo que você pode fazer no console — e cada uma dessas ações é uma transação real na cadeia, vinculada na [Evidência](https://docs.rome.builders/pt-br/apps-na-rome/bloom/evidence.md) página:

* **Emitir um ativo** — o assistente o implanta como três contratos (abaixo).
* **Revisar solicitações** — aprovar ou recusar cada uma (uma recusa traz um motivo ao qual o solicitante tem direito) e admitir um endereço aprovado na lista de permissões.
* **Gerenciar a lista de permissões** — adicionar um endereço, adicionar **um lote de endereços em uma única transação** (`batchAddToWhitelist`), ou remover um endereço; o token aplica a lista em toda transferência.
* **Restringir o ativo** — limitar as transferências à lista de permissões (o que torna a oferta final), ou remover a restrição.
* **Gerenciar oferta** — ler o total e cunhar ou queimar depois que você tiver a função.
* **Executar a venda** — abrir uma venda (quantidade e preço), fechá-la, recolher o estoque não vendido e sacar os recursos.
* **Definir e distribuir rendimento** — definir a moeda de pagamento e então distribuir um pagamento, que percorre os detentores uma transação por vez; os detentores excluídos são ignorados.
* **Gerenciar funções** — conceder uma função a um endereço, revogar uma ou renunciar à sua própria.

Cada uma é detalhada abaixo, com o que a cadeia impõe, na aba a que pertence.

***

## O console do emissor

![O console do emissor em /issuer, listando os ativos que esta implantação conhece e o estado de venda deles.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-c94de7c7a94a287a4d9b90a92b2b16022213b702%2Fissuer-console.png?alt=media\&token=657509e2-8263-4579-b54b-b6b4af33b6d6)

`/issuer` lista os ativos que você emitiu nesta cadeia e permite iniciar um novo.

* Conecte uma **Carteira EVM**. Um visitante desconectado, ou uma carteira Solana, vê um aviso para conectar o tipo certo de carteira em vez de um console vazio — uma carteira Solana não pode emitir, e isso é uma fronteira do produto que a cadeia impõe como uma segunda barreira independente.
* A tabela lista cada ativo com seu **nome e símbolo**, sua **fase**de ciclo de vida, e seu **estado da venda**  (um *Abra* selo ou *Fechado*).

Duas colunas — **Detentores** e **A revisar** — mostram um traço. A contagem de detentores precisa da enumeração da lista de permissões, e a fila de revisão é um armazenamento fora da cadeia no qual você faz login por ativo; um traço indica *não solicitado* onde um `0` alegaria um fato que o aplicativo não leu.

Pressione **Emitir um ativo** para abrir o assistente, ou selecione uma linha para abrir o console desse ativo.

***

## Criando um ativo: o assistente

![O assistente de criação em /create: os campos do ativo, depois seis cartões que acendem conforme suas transações são concluídas.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-94683a3a49ac2418aed8cc66dbf47fad940814f7%2Fcreate-wizard.png?alt=media\&token=38b47568-d343-483d-8ce1-f437164bdeae)

`/create` coleta quatro campos e então implanta seu ativo.

| Campo        | Regra                             |
| ------------ | --------------------------------- |
| **Nome**     | Obrigatório.                      |
| **Símbolo**  | Obrigatório.                      |
| **Oferta**   | Um número inteiro maior que zero. |
| **Decimais** | Um número inteiro de 0 a 18.      |

Pressione **Iniciar**. Se um campo estiver inválido, o assistente diz qual é e por quê, em vez de ficar atrás de um botão desativado. Quando o rascunho é válido, sua carteira é solicitada a assinar cada etapa em sequência.

### Por que ele implanta em partes

> **Um token é implantado como três contratos em várias transações — nunca em uma só.** O modelo de uma única transação do Arc `createToken` precisaria de **77 bloqueios de conta**, e Rome limita uma única transação a **62 travas**. Então o assistente implanta cada parte em sua própria transação e depois ganha status de fábrica via `ArcTokenFactoryV2.registerToken`. Esta é uma restrição de Rome tornada visível, não uma otimização opcional — e as proteções preservam exatamente o modelo de segurança a montante do Arc (proxy canônico, implementação na lista de permissões, o chamador possui a função de administrador do token, o registro é uma única vez). Veja [COMPLIANCE.md](https://docs.rome.builders/pt-br/apps-na-rome/bloom/compliance.md#what-rome-adds-and-what-registertoken-preserves).

### Os seis cartões

O assistente mostra seis cartões, que acompanham o progresso da implantação. Um cartão muda de **Aguardando** a **Assinando…** a **Concluído** (ou **Falhou**) conforme sua transação é concluída.

| # | Cartão                           | O que faz                                                                                                                           |
| - | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| 1 | **Implementação**                | A implementação compartilhada do ativo para esta cadeia — resolvida, nada a assinar. (Feito antes de qualquer etapa ser executada.) |
| 2 | **O ativo**                      | Implanta seu ativo e define nome, símbolo, oferta e decimais em uma única etapa.                                                    |
| 3 | **Quem pode mantê-lo**           | Implanta o próprio módulo de permissão deste ativo, com você como administrador.                                                    |
| 4 | **Imponha-o nas transferências** | Aponta o ativo para esse módulo, para que cada transferência seja verificada pelo próprio ativo.                                    |
| 5 | **Regras de rendimento**         | Implanta e vincula o módulo que decide quem é pago.                                                                                 |
| 6 | **Registro**                     | Registra o ativo — é isso que abre a venda e permite que você o atualize depois.                                                    |

Os seis cartões reúnem oito etapas subjacentes de implantação, então um único **Iniciar** resulta em **oito assinaturas**. Uma observação abaixo do botão diz *"Sua carteira pedirá que você assine cada etapa. Pare a qualquer momento e retome de onde parou — nada se perde."* O registro ser a etapa final é o que torna uma parada segura: o ativo é uma implantação real em cada fase, registrado no final.

Quando a execução termina, o assistente lê *"Emitido. Seu ativo está ativo em …"* com um link para o console do ativo em `/token/[address]`.

> **`inicializar` concede a você todas as funções.** O endereço que conduz o assistente — seu endereço EVM — recebe as funções de administrador, minerador/queimador, gestor/distribuidor de rendimento e atualizador do token, além da função de administrador do módulo da lista de permissões. A custódia da sua chave, portanto, faz parte da postura de conformidade do ativo: uma carteira de investidor perdida só pode ser recuperada por sua ação de administrador, e a aba **Direitos** torna visível o titular de cada poder. (`UPGRADER_ROLE` seja *não* é concedida automaticamente à fábrica — conceda-a explicitamente se quiser atualizações mediadas pela fábrica.)

***

## O console por ativo, e a porta de entrada de login

![A porta de entrada de login do console: assine uma mensagem com sua carteira — não há senha.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-a9377e3cad8460af1d9bb4eb3cf6f2a6a8f28b22%2Fconsole-signin.png?alt=media\&token=fdc19e4f-8724-4d36-999b-def1990685f9)

Ao abrir `/token/[address]` funciona **não** mostra o console imediatamente. Ele exibe uma **porta de login**:

> *"Entre para gerenciar este ativo. Assine uma mensagem com sua carteira — não há senha. Sua autoridade vem do próprio ativo, e ela é verificada novamente em cada ação, então revogá-la passa a valer na hora."*

Pressione **Entre com sua carteira**. Aqui está exatamente o que acontece:

1. Sua carteira é solicitada a `personal_sign` uma declaração curta e legível por humanos (encabeçada por *"Bloom — prove que você administra este ativo"*) que nomeia a única ação que ela autoriza — ler a fila de solicitações deste ativo — junto com o endereço do ativo, o id da cadeia e um carimbo de data e hora.
2. O app envia essa declaração assinada para `GET /api/applications`.
3. O **o servidor** a verifica: ele recupera seu endereço a partir da assinatura, confirma que a declaração é para esta cadeia e ainda está fresca (ela autoriza por uma janela de dois minutos, não por uma sessão), lê o **módulo de lista de permissões do próprio token** da cadeia e verifica se o seu endereço possui a função que a gravação na lista de permissões realmente exige — `MANAGER_ROLE` nesse módulo.
4. Se você a possuir, a fila é retornada e o console é renderizado. Se não, o servidor recusa com `403` e um motivo.

![A porta mostrando uma recusa citada: uma carteira que não administra este ativo é barrada.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-99040b8d3c752f0f84615b913d6b75fb0d36f81b%2Fconsole-refusal.png?alt=media\&token=29c3ffcf-b826-4aa7-b9da-41bdc3ec2e1e)

> **O ativo decide quem pode administrá-lo — não este app.** A função é verificada na lista de permissões **módulo**, não no token, e possuir uma função com o mesmo nome no token *não* não a transfere — são autoridades diferentes. Não há conta nem sessão: cada solicitação subsequente traz sua própria assinatura fresca, e é isso que *"verificada novamente em cada ação"* significa. Revogue a função de uma carteira na cadeia e ela deixa de conseguir entrar imediatamente.

Uma recusa mostra o motivo **entre aspas** — Bloom nunca escreve uma frase sobre por que uma carteira foi recusada. Se você recusar a assinatura na sua carteira, isso é o seu *"não"*, não do ativo, e isso não é relatado como uma recusa.

> **A porta é de quem-é-o-console, não de o-que-é-secreto.** Oferta, estado da venda, a lista de permissões e as funções são leituras públicas da cadeia que qualquer explorador responderá. O que a assinatura compra é a **fila de solicitações** — as declarações de outras pessoas — e o direito de sequer ver o console.

### O cabeçalho do console

Depois de entrar, o cabeçalho nomeia o ativo e mostra sua **fase** — o fato mais importante que ele tem:

| Fase         | Significado                                                                                                                                     |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| **Rascunho** | Nenhum módulo de permissão está vinculado ainda, então nada restringe quem pode manter isso.                                                    |
| **Abra**     | As transferências estão abertas e a oferta ainda pode mudar. Restringir o ativo torna sua oferta final, e isso não pode ser desfeito.           |
| **Restrito** | Somente endereços na lista de permissões podem manter isso, **e sua oferta é final** — nada mais pode ser cunhado ou queimado, permanentemente. |

Acima das abas, um resumo mostra quatro números — **Detentores · A revisar · Vendido · Rendimento pago**. Dois são lidos da cadeia e do armazenamento (*A revisar* depois que você tiver entrado; *Vendido* da vitrine); *Detentores* aguarda a contagem de detentores da pré-visualização de rendimento, e *Rendimento pago* aguarda o cursor do histórico de pagamentos que ainda está por vir. Cada célula em espera mostra um traço e explica do que precisa, em vez de uma `0` que alegaria um fato que ninguém pediu à cadeia.

***

## As seis abas

O console tem seis abas, nesta ordem: **Solicitações · Quem pode manter · Oferta · Venda · Rendimento · Direitos.**

Cada gravação nessas abas usa um controle compartilhado que exibe as **pré-condições nomeadas** e suas **consequências** *consequências* ante&#x73;*"Aguardando sua carteira…"*, *"Entrando na cadeia…"*&#x64;o botão, e nomeia sua fase conforme ele é executado (

### ). Nada deveria reverter para ensinar o que poderia ter sido verificado antes.

![A aba Solicitações — a fila de revisão, com uma solicitação pendente para aprovar ou recusar, e a costura de conformidade.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-8249de8b76f757101cc945ca4a2687103428839c%2Ftab-applications.png?alt=media\&token=ab0def9b-0bcb-49eb-b785-fd78e6fa2f92)

Esta aba lista quem se candidatou para manter o ativo. Cada linha mostra o endereço do solicitante, jurisdição, tipo de detentor, uma **Verificações** coluna (*Aprovado* se o seu provedor registrou um resultado, caso contrário *Declarado*), e uma **Status** (*A revisar*, *Aprovado*, *Recusado*). Expanda uma linha para ver seus fatos e dois controles: **Aprovar — pode manter** e **Recusar**. Uma recusa exige um motivo, que se torna a resposta do solicitante.

> **Aprovar são dois atos separados, e a aba os mantém honestos.** Ao pressionar **Aprovar** *registra* sua decisão no armazenamento de solicitações. Colocar o endereço na lista de permissões do ativo na cadeia é uma **segunda assinatura** — `batchAddToWhitelist` — e, até ela concluir, a linha informa isso. Quando a decisão registrada e a cadeia discordam, a aba nomeia a diferença e oferece a gravação que a corrige: **Admitir** para adicionar um endereço aprovado à lista de permissões, ou (para um endereço recusado ainda listado) o controle para removê-lo. O endereço não pode manter o ativo até que a gravação na lista de permissões seja concluída.

Uma nota permanente nesta aba — a **costura de conformidade** — indica onde seu próprio processo se encaixa:

> *"Nenhum documento é solicitado nem mantido aqui — as verificações são suas. Conecte seu provedor atrás da interface de `Solicitações` ou importe decisões que você já tenha tomado. Bloom registra o resultado e a cadeia registra um sim ou não contra o endereço."*

Essa é a interface que um emissor auto-hospedado substitui: troque a implementação do armazenamento de solicitações pela sua própria, persistente, e nenhum chamador muda. Bloom não realiza nenhuma verificação e não guarda nenhum documento.

### Quem pode mantê-lo — a porta das transferências

![A aba Quem-pode-mantê-lo — a contagem da lista de permissões e o controle de restringir transferências, mostrando as consequências de caminho sem volta.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-d32c410e3b5798d86dc5b914bce2f927eb4b1620%2Ftab-holders.png?alt=media\&token=aefe491d-2ce8-4478-a776-b9e612536d60)

Esta aba informa quantos endereços estão na lista de permissões do ativo e permite que você altere se a lista de permissões é **aplicada**:

* Quando as transferências estão **sem restrição**, ela oferece a opção de **restringir transferências à lista de permissões**. As consequências da gravação afirmam que fazer isso torna a oferta final e é um caminho sem volta para não administradores.
* Quando as transferências estão **restrito**, ela oferece a opção de **remover a restrição**. Suas consequências afirmam claramente que isso não é um desfazer.

Em um ativo *sem restrição* (rascunho) sem módulo de permissão vinculado, a aba diz isso — *"Nenhum módulo de permissão está vinculado, então nada restringe quem pode manter isso"* — e a alternância não é exibida.

> **O token verifica os dois lados de toda transferência.** Enquanto o ativo estiver restrito, uma transferência em que qualquer uma das partes não esteja na lista de permissões reverte na cadeia com um erro tipado. A mesma restrição vale para uma transferência por carteira EVM, uma transferência assinada por Solana, uma venda na vitrine e o movimento inicial de liquidez — não há caminho em torno disso, exceto pelo uso dos seus próprios poderes de administrador.

### Oferta

![A aba Oferta — unidades totais em existência.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-29eb2d741e5193eef3ea94a214a199f2eb404fe7%2Ftab-supply.png?alt=media\&token=2ab35474-ed9a-4d30-b978-5f69e1c0e7b9)

Esta aba informa a oferta total em existência, em unidades inteiras.

### Venda — abrir, fechar e receber os recursos

![A aba Venda — uma venda aberta, com os controles de fechar venda, recolher não vendidos e sacar recursos.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-573a99f9028a984b038162dc885a16b715673293%2Ftab-sale.png?alt=media\&token=18f59a19-9d83-4780-abf2-47e4a3e37d14)

Esta aba executa a venda principal por meio do contrato da vitrine.

* **Quando nenhuma venda está aberta**, ela oferece a opção de abrir uma: insira **Unidades para vender** e **Preço por unidade** (em `wUSDC`), então pressione **Abra a venda**. As pré-condições da gravação são exibidas primeiro — o token deve estar registrado, a vitrine deve deter o estoque da venda e a própria vitrine deve estar na lista de permissões do token que vende — então uma venda que ainda não pode ser aberta diz exatamente o que precisa.
* **Quando uma venda está aberta**, ela mostra quantas unidades restam da oferta e oferece **Fechar esta venda**.
* **Recolher unidades não vendidas** move o estoque não vendido da vitrine de volta para um destinatário (por padrão, você). Isso não é **não** um fechamento — a venda permanece habilitada, e a consequência da gravação diz isso, então uma recolha não pode ser confundida com um desfazimento.
* **Sacar recursos** envia os valores arrecadados pela vitrine para um endereço (por padrão, você). Os recursos se acumulam independentemente do estado da venda, então podem ser sacados tanto com a venda aberta quanto fechada.

### Rendimento — pagar detentores, um por transação

![A aba Rendimento — o campo de valor da distribuição, com o lembrete de definir primeiro uma moeda de pagamento.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-cc8150ea6fee72d99bd5a2254073779cbd896c11%2Ftab-yield.png?alt=media\&token=d190f7bd-1a1c-4ed2-b9a2-d27a399602f6)

Esta aba distribui um pagamento de rendimento aos detentores.

> **Uma distribuição é uma caminhada, não um clique.** Em Rome, `distributeYieldWithLimit` paga **um detentor por transação** (o limite de contas), então um pagamento é uma sequência de janelas, cada uma com sua própria assinatura. Você informa o valor uma vez, em unidades inteiras da moeda de pagamento, e ele fica travado quando a caminhada começa. A **primeiro** janela retira de você o pagamento completo e paga o primeiro detentor; cada janela seguinte apenas move dinheiro que já está dentro do contrato do token. Bloom relê o cursor da cadeia após cada janela — o conjunto de detentores é reordenado conforme os saldos mudam, e enviar um índice desatualizado faria recomeçar do zero e retiraria seu dinheiro uma segunda vez.

A aba mostra o progresso — *"Pagando o detentor N de M"* — e termina quando o cursor dá a volta. Se o ativo não tiver uma moeda de pagamento definida, a aba informa isso; definir a moeda de pagamento é o único campo de uma distribuição que só você pode escolher.

> **As cotas dos detentores restritos ficam no contrato.** Um endereço excluído pelo módulo de lista negra de rendimento é ignorado, e sua parcela proporcional permanece no contrato do token em vez de ser paga.

Pagamentos anteriores ainda não são mostrados — lê-los percorre os eventos de distribuição de volta até o primeiro bloco do ativo, o que exige um cursor de histórico que ainda está por vir. A aba diz isso dentro dela mesma em vez de mostrar uma `0`.

### Direitos — as funções

![A aba Direitos — toda função e se ela é mantida, e o controle de conceder / revogar / renunciar.](https://735130481-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F671PKS8ZQSNqtoC8PGvz%2Fuploads%2Fgit-blob-fb54f6c73c2d194dd5b6321bc3cb0af825f6f637%2Ftab-rights.png?alt=media\&token=6f545a79-96f8-4c9e-ac38-ce435e547deb)

Esta aba lista toda função que o token declara e se ela é mantida, cada uma lida com uma única `hasRole` chamada contra o token. Uma função que está **não** mantida aparece como tal em vez de ser omitida — em uma aba de direitos, uma linha ausente e uma *"não"* são fatos diferentes.

Abaixo da lista, um controle altera as funções:

| Ação                        | Age sobre                                                                   | Autoridade           |
| --------------------------- | --------------------------------------------------------------------------- | -------------------- |
| **Conceder a uma conta**    | Um endereço que você insere                                                 | `DEFAULT_ADMIN_ROLE` |
| **Revogar de uma conta**    | Um endereço que você insere                                                 | `DEFAULT_ADMIN_ROLE` |
| **Renunciar à sua própria** | Você mesmo (o OpenZeppelin exige que a confirmação seja o próprio chamador) | Você                 |

As opções de função são as próprias do token, então o controle nunca pode oferecer uma função que o token não tenha. Como em toda gravação, a linha de autoridade e a consequência são exibidas antes do botão, então a porta e seu caráter de caminho sem volta são declarados antes de você assinar.

***

## O que nunca toca o Bloom nem a cadeia

Para ser inequívoco sobre onde a conformidade mora:

| Coisa                                        | Onde fica                                                                                       |
| -------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| Documentos de KYC/AML e dados pessoais (PII) | Seu próprio sistema, com seus próprios fornecedores e retenção — **nunca** este app ou a cadeia |
| Sua decisão de admitir um endereço           | Um registro fora da cadeia; o armazenamento é seu                                               |
| O efeito on-chain dessa decisão              | Um booleano — `isWhitelisted(address)` — gravado por `batchAddToWhitelist`                      |
| Aplicação da regra                           | O contrato do ativo, em toda transferência                                                      |
| Quem pode administrar o ativo                | A função mantida no módulo de lista de permissões do ativo, verificada em toda solicitação      |

Para o modelo completo de conformidade, leia [COMPLIANCE.md](https://docs.rome.builders/pt-br/apps-na-rome/bloom/compliance.md); para a mecânica de duas vias (EVM e Solana) que seus detentores usam, leia [LANES.md](https://docs.rome.builders/pt-br/apps-na-rome/bloom/lanes.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/pt-br/apps-na-rome/bloom/issuing.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
