@softize/opus 12.10.0 → 12.11.0

package/registry/skills/build-opus-ui/references/ui-patterns.md

@@ -4,12 +4,24 @@
 - Campos, labels, mensagens e invalidações pertencem ao contrato quando são parte da
   operação, não a uma tela isolada.
 - URL representa estado que precisa sobreviver a refresh, deep link ou histórico.
-- `Page` fornece o `<main>`, o container centralizado com teto padrão de `72rem` e o header
-  de página. Alterar `className` apenas quando a superfície tiver uma necessidade real de
-  largura; não reconstruir esse container em cada rota.
-- `ContentHeader` compartilha a composição de título, descrição, metadados e ações entre
-  páginas e seções. `variant` define o destaque visual; `level` preserva separadamente a
-  hierarquia semântica do heading.
+- `Page` fornece o `<main>` e o container centralizado com teto padrão de `80rem`. Sua forma
+  explícita é `Page > PageHeader (PageTitle, PageDescription, PageMeta, PageActions) + PageBody`;
+  `title`, `description`, `meta` e `actions` no próprio `Page` são a abreviação para o caso direto.
+  Não misturar as duas formas. Alterar `className` apenas quando a superfície tiver uma necessidade
+  real de largura; não reconstruir esse container em cada rota.
+- `PageState` substitui todo o conteúdo principal quando a página carrega, falha ou está vazia. Na
+  forma curta ele pode ser escrito como filho direto de `Page`, que cria o `PageBody`; na forma
+  explícita, fica dentro de `PageBody`. O cabeçalho permanece visível. Estados de seção ou coleção
+  continuam em `DataState`, `ActionView`, `ActionList` ou `Alert`; não elevar uma falha parcial a
+  estado da página.
+- `Content` delimita uma seção e segue a mesma anatomia: `Content > ContentHeader (ContentTitle,
+  ContentDescription, ContentMeta, ContentActions) + ContentBody`. `ContentHeader` nunca fica
+  solto. `title`, `description`, `meta` e `actions` no `Content` são a abreviação para o caso
+  direto e não podem ser misturados ao header explícito. `level` preserva a hierarquia semântica
+  do heading.
+- Card, Drawer e Pane nomeiam a região principal como `CardBody`, `DrawerBody` e `PaneBody`.
+  `*Content` permanece reservado a raízes técnicas ou painéis cujo papel não é o corpo de uma
+  estrutura, como `DialogContent`, `PopoverContent` e `TabsContent`.
 - Componentes compartilhados não impõem margem externa; páginas e shells compõem layout.
 - A fonte raiz pertence ao navegador e à aplicação. Medidas escaláveis usam `rem` ou a escala
   relativa do Tailwind; `px` fica restrito a hairlines e compensações ligadas a essas bordas.
@@ -55,18 +67,23 @@
   valor trunca no trigger e a opção inteira fica na lista. Não dimensionar filtro pelo conteúdo
   nem pela label; o modal usa `w-full`.
 - Catálogo e API efetivos vêm dos exports da versão instalada, não de memória ou exemplo antigo.
+- Em componentes semânticos, `context` responde por que há destaque e `variant` responde como ele
+  aparece. O vocabulário canônico é `neutral | primary | info | success | warning | danger`; as
+  variantes visuais são `solid | subtle | outline | ghost | link`, limitadas por componente.
+  `light`/`dark` são temas, `secondary` não substitui estado neutro e `destructive` é comportamento
+  de action projetado visualmente como `danger`.
 
 ## Dicionários e dimensões
 
 O dicionário declara o papel; a tela só escolhe onde o valor fica. Tabela de decisão aplicada
 por `DictionaryValue` e pelas colunas de `ActionList`:
 
-| Papel declarado | Exemplos | Forma | Variante | Ícone | Tooltip |
-|---|---|---|---|---|---|
-| `classification` | Tipo de cliente, categoria, natureza | Badge | `outline`; ignora `tone` | se a entrada declara `icon` do catálogo | se `description` acrescenta ao rótulo |
-| `status` | Aberto, resolvido, degradado | Badge | tonal pelo `tone`; `neutral` sem tom; nunca `outline` | idem | idem |
-| `stage` | Prospect, cliente; etapa do funil | Badge | igual a `status` | idem | idem |
-| `plain` ou ausente | Fonte, formato, período | Texto | — | idem | idem |
+| Papel declarado | Exemplos | Forma | Contexto | Variante | Ícone | Tooltip |
+|---|---|---|---|---|---|---|
+| `classification` | Tipo de cliente, categoria, natureza | Badge | `neutral` | `outline`; ignora `context` da entrada | se a entrada declara `icon` do catálogo | se `description` acrescenta ao rótulo |
+| `status` | Aberto, resolvido, degradado | Badge | pela entrada; `neutral` por padrão | `subtle`; nunca `outline` | idem | idem |
+| `stage` | Prospect, cliente; etapa do funil | Badge | igual a `status` | `subtle` | idem | idem |
+| `plain` ou ausente | Fonte, formato, período | Texto | — | — | idem | idem |
 
 Regras que não dependem da tabela:
 
@@ -88,7 +105,7 @@ export const customerKindDict = t.dict(
   { doc: 'Natureza da parte no cadastro global.', presentation: 'classification' },
 )
 export const customerStageDict = t.dict(
-  { prospect: { label: 'Prospect' }, customer: { label: 'Cliente', tone: 'success' } },
+  { prospect: { label: 'Prospect' }, customer: { label: 'Cliente', context: 'success' } },
   { doc: 'Estágio comercial atual da parte.', presentation: 'stage' },
 )
 // contrato:
@@ -112,7 +129,7 @@ cells={{
   ),
   stage: (item) =>
     item.stage === 'customer'
-      ? <Badge variant="secondary">Cliente</Badge>
+      ? <Badge context="neutral" variant="solid">Cliente</Badge>
       : <Badge variant="outline">Prospect</Badge>,
 }}
 
@@ -124,7 +141,13 @@ cells={{
 
 // Tooltip que repete o rótulo; cor como único sinal.
 <Tooltip>
-  <TooltipTrigger><Dot variant="success" /></TooltipTrigger>
+  <TooltipTrigger><Dot context="success" /></TooltipTrigger>
   <TooltipContent>Cliente</TooltipContent>
 </Tooltip>
+
+// Contexto semântico usado como variante: a IA perdeu um eixo da API.
+<Badge variant="success">Concluído</Badge>
+
+// Risco comportamental usado como nome visual.
+<Button variant="destructive">Excluir</Button>
 ```

package/registry/skills/model-opus-dictionary/SKILL.md

@@ -35,7 +35,8 @@ da mesma instância, sem catálogo repetido em enum, opção estática ou format
    - **status** — situação operacional que muda com o tempo;
    - **stage** — etapa de um ciclo ou funil;
    - **plain** — valor que só precisa ser legível (o mesmo efeito de omitir).
-   Por entrada, declarar `tone` somente em status e estágio, `icon` somente com nome existente no
+   Por entrada, declarar `context` somente em status e estágio, usando `neutral`, `info`, `success`,
+   `warning` ou `danger`; `icon` somente com nome existente no
    catálogo `iconPickerIcons`, e `description` somente quando acrescentar algo ao rótulo. `doc`
    continua sendo o entendimento de negócio para manifest e Lens; não é tooltip.
 4. Derivar o schema por `.zod()` e usá-lo em todo contrato que valide o código; não redeclarar a
@@ -68,7 +69,8 @@ contrato ou componente mapeado, regenerar com `opus copy` e executar os checks d
 - Não tratar metadata de dicionário como autorização ou invariante de integridade.
 - Não omitir `presentation` esperando que a tela deduza o papel pelo nome do dicionário; sem
   papel declarado, o valor é texto.
-- Não declarar `tone` em classificação, nem `icon` fora do catálogo, nem `description` que
+- Não declarar `context` em classificação, nem usar o alias legado `tone` em código novo, nem
+  `icon` fora do catálogo, nem `description` que
   repita o rótulo.
 
 ## Recursos

package/registry/skills/model-opus-dictionary/references/evaluations.md

@@ -11,8 +11,9 @@
   interface lê rótulos por `labelFor`/`metaFor`.
 - Execução de apresentação: dado um cadastro com “Pessoa física/Empresa” e “Prospect/Cliente”,
   declarar o primeiro como `classification` com ícones `user` e `building` do catálogo e o segundo
-  como `stage` com `tone` explícito, sem `description` que repita o rótulo; provar que o manifest
-  projeta `presentation` e que `t.dict` rejeita `presentation` ou `tone` fora do vocabulário.
-- Reprova: declarar `tone` em uma classificação, inventar `icon` fora do catálogo, copiar `doc`
+  como `stage` com `context` explícito, sem `description` que repita o rótulo; provar que o manifest
+  projeta `presentation` e `context` e que `t.dict` rejeita valores fora do vocabulário.
+- Reprova: declarar `context` em uma classificação, usar o alias legado `tone` em código novo,
+  inventar `icon` fora do catálogo, copiar `doc`
   para `description` ou deixar `presentation` ausente em um status esperando que a tela infira o
   badge.

package/registry/templates/app/src/App.tsx

@@ -26,7 +26,7 @@ export function App(): React.ReactElement {
             {items.map((t) => (
               <li key={t.id} className="flex items-center justify-between gap-2 text-sm">
                 <span>{t.title}</span>
-                <Badge variant={t.done ? 'default' : 'secondary'}>{t.done ? 'Feita' : 'Aberta'}</Badge>
+                <Badge context={t.done ? 'success' : 'neutral'}>{t.done ? 'Feita' : 'Aberta'}</Badge>
               </li>
             ))}
           </ul>

package/src/core/dictionary.ts

@@ -8,14 +8,20 @@
 
 import { getLogicalType } from './logical-type.ts'
 import type { LogicalTypeMeta } from './types.ts'
+import {
+  DICT_CONTEXTS,
+  isDictContext,
+  type DictContext,
+} from './ui-context.ts'
 
 /** Papel de apresentação declarado no nível do dicionário. */
 export const DICT_PRESENTATIONS = ['classification', 'status', 'stage', 'plain'] as const
 export type DictPresentation = (typeof DICT_PRESENTATIONS)[number]
 
-/** Tom explícito de uma entrada — honrado apenas por status e estágios. */
-export const DICT_TONES = ['neutral', 'info', 'success', 'warning', 'danger'] as const
-export type DictTone = (typeof DICT_TONES)[number]
+/** @deprecated Use `DICT_CONTEXTS` (ADR 0006). */
+export const DICT_TONES = DICT_CONTEXTS
+/** @deprecated Use `DictContext` (ADR 0006). */
+export type DictTone = DictContext
 
 /**
  * Meta de cada chave de um dict. `label` obrigatório; resto livre.
@@ -24,7 +30,7 @@ export type DictTone = (typeof DICT_TONES)[number]
  *   entra/sai) — a fonte rica de consulta rápida; flui pro manifest/Lens e NÃO vira tooltip.
  * - `description` é o texto curto voltado à pessoa: aparece no tooltip do `DictionaryValue`
  *   e como apoio de opção. Não repetir o rótulo — descrição igual ao rótulo não renderiza.
- * - `tone` é o tom tonal do badge de status/estágio; classificação ignora.
+ * - `context` é o contexto semântico do status/estágio; classificação ignora.
  * - `icon` é o identificador estável do catálogo de ícones do Opus (`iconPickerIcons`);
  *   nome fora do catálogo não renderiza ícone.
  * - `color` permanece metadata livre (lida pela Lens); o renderer não a interpreta.
@@ -33,7 +39,9 @@ export interface DictEntryMeta {
   label: string
   doc?: string
   description?: string
-  tone?: DictTone
+  context?: DictContext
+  /** @deprecated Use `context`. Compatibilidade temporária da ADR 0006. */
+  tone?: DictContext
   icon?: string
   color?: string
   order?: number
@@ -44,8 +52,16 @@ export function isDictPresentation(value: unknown): value is DictPresentation {
   return typeof value === 'string' && (DICT_PRESENTATIONS as readonly string[]).includes(value)
 }
 
-export function isDictTone(value: unknown): value is DictTone {
-  return typeof value === 'string' && (DICT_TONES as readonly string[]).includes(value)
+/** @deprecated Use `isDictContext` (ADR 0006). */
+export const isDictTone = isDictContext
+
+/** Normaliza a metadata canônica e seu alias temporário. */
+export function dictionaryEntryContext(entry: DictEntryMeta): DictContext | undefined {
+  return isDictContext(entry.context)
+    ? entry.context
+    : isDictContext(entry.tone)
+      ? entry.tone
+      : undefined
 }
 
 /** Forma normalizada de um dicionário, independente de onde a meta foi lida. */
@@ -92,7 +108,11 @@ export interface DictionaryValuePresentation {
   /** False quando o valor não está no dicionário. */
   known: boolean
   presentation: DictPresentation
-  /** `null` = texto; `'outline'` = classificação; tom = badge tonal de status/estágio. */
+  /** Contexto semântico; `null` quando a apresentação é texto. */
+  context: DictContext | null
+  /** Tratamento visual; `null` quando a apresentação é texto. */
+  variant: 'subtle' | 'outline' | null
+  /** @deprecated Use `context` e `variant`. */
   badge: 'outline' | DictTone | null
   /** Identificador do catálogo, só quando declarado na entrada. */
   icon: string | null
@@ -115,8 +135,8 @@ export function dictionaryDescription(label: string, description: unknown): stri
  * Aplica a tabela de decisão da ADR 0003:
  *
  * | papel            | forma | variante                  |
- * | classification   | badge | outline (ignora `tone`)   |
- * | status / stage   | badge | tonal: `tone` ?? neutral  |
+ * | classification   | badge | neutral + outline            |
+ * | status / stage   | badge | `context` + subtle           |
  * | plain / ausente  | texto | —                         |
  *
  * Ícone só quando declarado; tooltip só quando `description` acrescenta. Valor fora do
@@ -132,20 +152,38 @@ export function presentDictionaryValue(
     ? descriptor.entries[value]
     : undefined
   if (entry === undefined || typeof entry.label !== 'string') {
-    return { value, label: value, known: false, presentation, badge: null, icon: null, description: null }
+    return {
+      value,
+      label: value,
+      known: false,
+      presentation,
+      context: null,
+      variant: null,
+      badge: null,
+      icon: null,
+      description: null,
+    }
   }
-  const badge: DictionaryValuePresentation['badge'] =
+  const context: DictionaryValuePresentation['context'] =
+    presentation === 'classification'
+      ? 'neutral'
+      : presentation === 'status' || presentation === 'stage'
+        ? (dictionaryEntryContext(entry) ?? 'neutral')
+        : null
+  const variant: DictionaryValuePresentation['variant'] =
     presentation === 'classification'
       ? 'outline'
       : presentation === 'status' || presentation === 'stage'
-        ? (isDictTone(entry.tone) ? entry.tone : 'neutral')
+        ? 'subtle'
         : null
   return {
     value,
     label: entry.label,
     known: true,
     presentation,
-    badge,
+    context,
+    variant,
+    badge: variant === 'outline' ? 'outline' : context,
     icon: typeof entry.icon === 'string' && entry.icon.length > 0 ? entry.icon : null,
     description: dictionaryDescription(entry.label, entry.description),
   }

package/src/core/index.ts

@@ -138,12 +138,22 @@ export { normalizeTraceContext } from './trace.ts'
 // `@softize/opus/schema` re-exporta os dois pra manter a API de sempre.
 export { attachLogicalType, getLogicalType } from './logical-type.ts'
 
+// — Contextos semânticos de UI (ADR 0006) ————————————————————————————————————
+export {
+  UI_CONTEXTS,
+  DICT_CONTEXTS,
+  isUiContext,
+  isDictContext,
+} from './ui-context.ts'
+export type { UiContext, DictContext } from './ui-context.ts'
+
 // — Dicionários (apresentação declarada — ADR 0003) ————————————————————————————
 export {
   DICT_PRESENTATIONS,
   DICT_TONES,
   isDictPresentation,
   isDictTone,
+  dictionaryEntryContext,
   dictionaryDescriptor,
   dictionaryDescription,
   presentDictionaryValue,

package/src/core/ui-context.ts

@@ -0,0 +1,29 @@
+/**
+ * Famílias semânticas compartilhadas entre contratos e UI (ADR 0006).
+ *
+ * Contexto responde por que um realce existe; cada componente decide como materializá-lo.
+ * Tema (light/dark), geometria e variante visual são eixos independentes.
+ */
+export const UI_CONTEXTS = [
+  'neutral',
+  'primary',
+  'info',
+  'success',
+  'warning',
+  'danger',
+] as const
+
+export type UiContext = (typeof UI_CONTEXTS)[number]
+
+/** Contextos válidos para estados e estágios de domínio. */
+export const DICT_CONTEXTS = ['neutral', 'info', 'success', 'warning', 'danger'] as const
+
+export type DictContext = (typeof DICT_CONTEXTS)[number]
+
+export function isUiContext(value: unknown): value is UiContext {
+  return typeof value === 'string' && (UI_CONTEXTS as readonly string[]).includes(value)
+}
+
+export function isDictContext(value: unknown): value is DictContext {
+  return typeof value === 'string' && (DICT_CONTEXTS as readonly string[]).includes(value)
+}

package/src/schema/drivers/zod.ts

@@ -36,6 +36,7 @@ import {
   type DictEntryMeta,
   type DictPresentation,
 } from '../../core/dictionary.ts'
+import { DICT_CONTEXTS, isDictContext } from '../../core/ui-context.ts'
 import {
   formatDatetime,
   formatDate,
@@ -656,7 +657,8 @@ function isLogicalType(value: unknown): value is LogicalType<unknown> {
 /**
  * Meta de cada chave de um dict — o tipo mora no core (`@softize/opus/core`, ADR 0003) e é
  * reexportado aqui pra manter a API: `label` obrigatório, `doc` (negócio, manifest/Lens),
- * `description` (tooltip), `tone` (badge tonal de status/estágio), `icon` (catálogo).
+ * `description` (tooltip), `context` (contexto semântico de status/estágio), `icon` (catálogo).
+ * `tone` permanece como alias temporário de compatibilidade.
  */
 export type { DictEntryMeta }
 
@@ -716,16 +718,23 @@ const dict = <const M extends Record<string, DictEntryMeta>>(
       `t.dict: presentation "${String(opts.presentation)}" inválida; use ${DICT_PRESENTATIONS.join(' | ')}`,
     )
   }
-  const tonal = opts?.presentation === 'status' || opts?.presentation === 'stage'
+  const contextual = opts?.presentation === 'status' || opts?.presentation === 'stage'
   for (const key of keys) {
-    const tone = (entries[key] as DictEntryMeta).tone
-    if (tone === undefined) continue
-    if (!isDictTone(tone)) {
-      throw new Error(`t.dict: tone "${String(tone)}" inválido em "${key}"; use ${DICT_TONES.join(' | ')}`)
+    const entry = entries[key] as DictEntryMeta
+    if (entry.context !== undefined && entry.tone !== undefined) {
+      throw new Error(`t.dict: use context ou tone em "${key}", nunca os dois`)
     }
-    if (!tonal) {
+    const context = entry.context ?? entry.tone
+    if (context === undefined) continue
+    const legacy = entry.context === undefined
+    if (!(legacy ? isDictTone(context) : isDictContext(context))) {
+      const values = legacy ? DICT_TONES : DICT_CONTEXTS
+      const field = legacy ? 'tone' : 'context'
+      throw new Error(`t.dict: ${field} "${String(context)}" inválido em "${key}"; use ${values.join(' | ')}`)
+    }
+    if (!contextual) {
       throw new Error(
-        `t.dict: tone em "${key}" exige presentation "status" ou "stage" (classificação usa outline; plain é texto)`,
+        `t.dict: ${legacy ? 'tone' : 'context'} em "${key}" exige presentation "status" ou "stage" (classificação usa outline; plain é texto)`,
       )
     }
   }

package/src/ui/components/patterns/action-form-card.tsx

@@ -6,22 +6,24 @@
  */
 import {
   Card,
-  CardContent,
+  CardBody,
   CardDescription,
   CardFooter,
   CardHeader,
   CardTitle,
-} from '../primitives/card.tsx'
-import { ActionForm, type ActionFormProps } from './form.tsx'
+} from "../primitives/card.tsx";
+import { ActionForm, type ActionFormProps } from "./form.tsx";
 
-export interface ActionFormCardProps<TInput extends Record<string, unknown>, TData>
-  extends Omit<ActionFormProps<TInput, TData>, 'body' | 'footer'> {
+export interface ActionFormCardProps<
+  TInput extends Record<string, unknown>,
+  TData,
+> extends Omit<ActionFormProps<TInput, TData>, "body" | "footer"> {
   /** Título do header do card. Sem ele, o card começa direto no conteúdo. */
-  title?: string
+  title?: string;
   /** Subtítulo opcional, abaixo do título. */
-  description?: string
+  description?: string;
   /** Classes do Card (a superfície). `className` vai pro <form>. */
-  cardClassName?: string
+  cardClassName?: string;
 }
 
 export function ActionFormCard<TInput extends Record<string, unknown>, TData>({
@@ -35,14 +37,18 @@ export function ActionFormCard<TInput extends Record<string, unknown>, TData>({
       {(title !== undefined || description !== undefined) && (
         <CardHeader>
           {title !== undefined && <CardTitle>{title}</CardTitle>}
-          {description !== undefined && <CardDescription>{description}</CardDescription>}
+          {description !== undefined && (
+            <CardDescription>{description}</CardDescription>
+          )}
         </CardHeader>
       )}
       <ActionForm
         {...rest}
-        body={(fields) => <CardContent>{fields}</CardContent>}
-        footer={(actions) => <CardFooter className="justify-end">{actions}</CardFooter>}
+        body={(fields) => <CardBody>{fields}</CardBody>}
+        footer={(actions) => (
+          <CardFooter className="justify-end">{actions}</CardFooter>
+        )}
       />
     </Card>
-  )
+  );
 }

package/src/ui/components/patterns/confirm.tsx

@@ -2,7 +2,7 @@
  * `dialog` — o trio imperativo (alert · confirm · prompt) em UMA linha.
  *
  *   await dialog.alert({ title: 'Sessão expirada', description: 'Você será desconectado.' })
- *   if (await dialog.confirm({ title: 'Excluir a sessão?', variant: 'destructive' })) …
+ *   if (await dialog.confirm({ title: 'Excluir a sessão?', context: 'danger' })) …
  *   const nome = await dialog.prompt({ title: 'Nome do snapshot' })
  *
  * Mesma forma do `toast` (superfície imperativa + host no shell), com uma diferença: eles
@@ -19,6 +19,7 @@
  */
 
 import * as React from 'react'
+import type { UiContext } from '../../../core/ui-context.ts'
 import {
   AlertDialog,
   AlertDialogAction,
@@ -50,13 +51,17 @@ export interface AlertOptions extends DialogBase {}
 /** `confirm` — pergunta de sim/não. */
 export interface ConfirmOptions extends DialogBase {
   cancel?: string
-  /** `destructive` pinta o botão de confirmar — o que apaga tem que parecer o que apaga. */
+  /** Contexto do botão de confirmação. */
+  context?: Extract<UiContext, 'primary' | 'danger'>
+  /** @deprecated Use `context="danger"`. */
   variant?: 'default' | 'destructive'
 }
 
 /** `prompt` — uma string livre. Form de verdade (campos, contrato) → ActionFormDialog. */
 export interface PromptOptions extends DialogBase {
   cancel?: string
+  context?: Extract<UiContext, 'primary' | 'danger'>
+  /** @deprecated Use `context="danger"`. */
   variant?: 'default' | 'destructive'
   placeholder?: string
   defaultValue?: string
@@ -79,6 +84,16 @@ function requireHost(fn: string): Error | null {
   )
 }
 
+function rejectAmbiguousContext(
+  fn: string,
+  options: ConfirmOptions | PromptOptions,
+): Error | null {
+  if (options.context === undefined || options.variant === undefined) return null
+  return new Error(
+    `${fn} não permite combinar context com uma variante semântica legada.`,
+  )
+}
+
 export const dialog = {
   /** Avisa e espera o "OK". `Promise<void>` — só reconhecimento, sem decisão. */
   alert(options: AlertOptions): Promise<void> {
@@ -90,6 +105,8 @@ export const dialog = {
   },
   /** Pergunta sim/não. `Promise<boolean>` — fechar/ESC resolve `false`. */
   confirm(options: ConfirmOptions): Promise<boolean> {
+    const ambiguous = rejectAmbiguousContext('dialog.confirm()', options)
+    if (ambiguous !== null) return Promise.reject(ambiguous)
     const err = requireHost('dialog.confirm()')
     if (err !== null) return Promise.reject(err)
     return new Promise<boolean>((resolve) => {
@@ -98,6 +115,8 @@ export const dialog = {
   },
   /** Pede uma string. `Promise<string | null>` — fechar/ESC/Cancelar resolve `null`. */
   prompt(options: PromptOptions): Promise<string | null> {
+    const ambiguous = rejectAmbiguousContext('dialog.prompt()', options)
+    if (ambiguous !== null) return Promise.reject(ambiguous)
     const err = requireHost('dialog.prompt()')
     if (err !== null) return Promise.reject(err)
     return new Promise<string | null>((resolve) => {
@@ -154,6 +173,9 @@ export function DialogHost(): React.ReactElement {
   }
 
   const variant = current !== undefined && current.kind !== 'alert' ? current.variant : undefined
+  const context = current !== undefined && current.kind !== 'alert'
+    ? current.context ?? (variant === 'destructive' ? 'danger' : 'primary')
+    : 'primary'
   const defaultAction = current?.kind === 'alert' ? 'OK' : 'Confirmar'
 
   return (
@@ -210,7 +232,8 @@ export function DialogHost(): React.ReactElement {
               </AlertDialogCancel>
             )}
             <AlertDialogAction
-              variant={variant === 'destructive' ? 'destructive' : 'default'}
+              context={context}
+              variant="solid"
               onClick={() => drop(current.id, (p) => accept(p, text))}
             >
               {current.action ?? defaultAction}