# Ask User

> Patrón reutilizable para presentar al usuario opciones explícitas y detener la ejecución hasta que responda; funciona en Telegram, Discord, CLI o cualquier agente con herramienta de mensajes.

Fuente: https://skillsagentes.com/skills/garrytan/gbrain/ask-user
Markdown: https://skillsagentes.com/skills/garrytan/gbrain/ask-user.md

Repositorio: https://github.com/garrytan/gbrain
Autor: garrytan
Licencia: MIT
Actualizado: hace 9 días
Coste de contexto: 73 tok instalada, 2.1k tok al activarse, 2.1k tok con todos los archivos del bundle
Bundle: 1 archivo, 8 KB
Permisos que pide: ninguno declarado

## Instalación

Un skill son archivos markdown: los mismos archivos valen para cualquier agente y lo único que cambia es el directorio de destino, es decir la bandera `--agent`. Añade `-g` para instalarlo en todos los proyectos de la máquina.

```bash
# Claude Code
npx -y skills add garrytan/gbrain --skill ask-user --agent claude-code
# Cursor
npx -y skills add garrytan/gbrain --skill ask-user --agent cursor
# Codex
npx -y skills add garrytan/gbrain --skill ask-user --agent codex
# Gemini CLI
npx -y skills add garrytan/gbrain --skill ask-user --agent gemini
# Windsurf
npx -y skills add garrytan/gbrain --skill ask-user --agent windsurf
# Cline
npx -y skills add garrytan/gbrain --skill ask-user --agent cline
```

## Qué hace

- Presenta al usuario entre 2 y 4 opciones claras con una vía de escape (Skip/Cancel)
- Detiene el turno inmediatamente tras presentar las opciones, sin llamadas a herramientas ni acciones preventivas
- Espera la respuesta del usuario y la usa para bifurcar la ejecución en el siguiente turno
- Maneja respuestas en texto libre haciendo coincidencia difusa con las etiquetas de las opciones

## Cuándo usarla

- Solicitudes ambiguas con varias interpretaciones válidas
- Operaciones destructivas (borrados masivos, sobrescrituras)
- Decisiones de archivo o enrutamiento ('¿dónde debería ir esto?')
- Cualquier bifurcación donde elegir mal desperdiciaría trabajo significativo

## Cuándo no

- Instrucciones claras e inequívocas: simplemente hazlo
- Decisiones de bajo riesgo: elige la mejor opción y menciónalo
- Operaciones urgentes donde el retraso cuesta más que una elección equivocada

## Qué la activa

- "Pregúntame antes de borrar esos archivos de caché"
- "Dame opciones para archivar esta nota de reunión"
- "Necesito elegir cómo importar mis contactos de Google, preséntame las opciones"

## Archivos

- SKILL.md — 8 KB

## SKILL.md

Reproducido tal cual desde garrytan/gbrain bajo MIT. Esta sección es el documento original y está en inglés.

# Ask User — Choice Gate Pattern

## Contract

- Present 2-4 options (no more — decision paralysis kicks in past 4).
- Always include an escape hatch (Skip, Cancel, or "none of these").
- Stop the turn immediately after presenting choices. No follow-up tool calls,
  no preemptive action, no default-and-proceed.
- The user's response triggers the next turn. Acknowledge briefly, then branch.
- One question per message — never stack multiple choice gates.
- Self-explanatory option labels: action verb plus brief qualifier, not "Option 1".

## What This Is

A **formalized pattern** for presenting users with 2-4 options and **stopping
execution** until they respond. This is the canonical way to gate on user input
in any GBrain-powered agent.

This is NOT a traditional async/await. In an LLM agent, "gating" means:
1. Present the choices (buttons or numbered options)
2. Explicitly stop the current turn (do not proceed)
3. The user's response triggers the next turn
4. Read the response and branch accordingly

## When To Use

- Ambiguous requests with multiple valid interpretations
- Destructive operations (bulk deletes, overwrites)
- Filing/routing decisions ("where should this go?")
- Priority triage ("which should I do first?")
- Cold-start phase gates ("ready for the next import source?")
- Any fork where the wrong default wastes significant work

## When NOT To Use

- Clear, unambiguous instructions → just do it
- Low-stakes decisions → pick the best option and mention it
- Time-critical operations where delay costs more than a wrong choice
- When the user has already expressed a preference

## How To Present Choices

### Platform-agnostic format (works everywhere)

Present choices as a clear question with numbered or labeled options:

```
🔀 **How should I handle this?**

[context about the decision — 1-3 lines max]

1. **Option A** — short description
2. **Option B** — short description
3. **Option C** — short description
4. **Skip** — do nothing for now
```

### With inline buttons (Telegram, Discord, Slack)

If the platform supports interactive buttons, use them:

```json
{
  "message": "🔀 **How should I handle this?**\n\n<context>",
  "buttons": [
    { "label": "Option A — description", "value": "option_a" },
    { "label": "Option B — description", "value": "option_b" },
    { "label": "Skip", "value": "skip" }
  ]
}
```

### With the `clarify` tool (OpenClaw agents)

Some OpenClaw agents have a built-in `clarify` tool that presents choices natively:

```
clarify(
  question: "How should I handle this?",
  choices: [
    "Option A — description",
    "Option B — description",
    "Option C — description",
    "Skip for now"
  ]
)
```

## Constraints

- **2-4 options max.** More than 4 creates decision paralysis.
- **Labels must be self-explanatory.** The user shouldn't need to re-read context.
- **Always include an escape hatch.** At minimum: "Skip" or "Cancel" as the last option.
- **One question per message.** Never stack multiple choice gates.

## How To Gate (CRITICAL)

After presenting choices, **you MUST stop your turn.** Do not:
- ❌ Continue with "while you decide, I'll start on..."
- ❌ Pick a default and proceed
- ❌ Send follow-up messages before the user responds
- ❌ Make assumptions about which option they'll pick

Instead:
- ✅ End your message with a brief note that you're waiting
- ✅ Stop. Full stop. No more tool calls.

## How To Handle The Response

When the user responds:

1. **Read the response** — button click, number, or text
2. **Acknowledge briefly** — "Got it, going with Option A."
3. **Branch and execute** the chosen path
4. If unclear, ask again

### Handling text responses

Users sometimes type instead of clicking. Handle gracefully:
- "the first one" / "A" / "1" → map to first option
- "merge" → fuzzy match against option labels/values
- "actually, none of those" → present alternatives or ask what they want
- Unrelated message → the user moved on; drop the gate

## Formatting Guidelines

### Question line emoji prefix

Signal the decision type:
- 🔀 Routing/filing decisions
- ⚠️ Destructive/risky operations
- 🎯 Priority/triage decisions
- 💡 Creative/strategic forks
- 📋 Workflow/process choices
- 🔐 Credential/security decisions

### Context block

1-3 lines maximum. The user should understand the decision in under 5 seconds.

### Button/option labels

Format: `Action verb — brief qualifier`
- ✅ "Merge — combine with existing page"
- ✅ "Create new — separate meeting page"
- ❌ "Option 1"
- ❌ "Click here to merge the content into the existing brain page"

## Examples

### Cold-start phase gate
```
📋 **Phase 2: Google Contacts**

I can import your Google Contacts to seed the people/ directory.
This creates a brain page for each real contact (~200 pages).

1. **Import via ClawVisor** — secure credential gateway
2. **Import via direct OAuth** — simpler, agent holds tokens
3. **Import from Google Takeout export** — offline, from file
4. **Skip** — move to the next phase
```

### Filing decision
```
🔀 **Where should this go?**

Meeting notes from call with Jane Smith. She already has a page at
people/jane-smith.md and there's a deal page at deals/acme-corp.md.

1. **Merge into Jane's page** — add to her timeline
2. **Add to Acme deal page** — this was primarily a deal discussion
3. **New meeting page** — standalone at meetings/2026-01-15-jane-acme.md
4. **Skip** — don't file this
```

### Destructive operation
```
⚠️ **About to delete 847 stale cache files (2.3 GB)**

These haven't been accessed in 90+ days. They can be re-fetched
but that takes ~4 hours.

1. **Delete them** — free up space now
2. **Archive first** — upload to cloud storage, then delete
3. **Keep them** — no changes
4. **Show me the list** — let me review before deciding
```

## Integration With Other Skills

This pattern is used by:
- **cold-start** — phase gates for each import source
- **ingest** — routing decisions for ambiguous content
- **enrich** — merge vs create decisions for entity pages
- **brain-ops** — filing location decisions
- **meeting-ingestion** — where to file meeting notes
- **archive-crawler** — scan vs full ingestion gate

When building a new skill that needs user input at a decision point,
reference this pattern rather than inventing a new one.

## Anti-Patterns

- **Continuing the turn after presenting choices.** "While you decide, I'll start on..."
  defeats the gate. Stop. Wait. The whole point is that the user controls what happens next.
- **Picking a default and proceeding silently.** If the question matters enough to ask,
  it matters enough to wait. Silent defaults erode trust the next time you do ask.
- **More than 4 options.** Decision paralysis is real. Group, summarize, or split into
  staged questions instead.
- **No escape hatch.** Every choice gate must let the user decline. "None of these"
  / "Skip" / "Cancel" is mandatory.
- **Stacking multiple choice gates in one message.** The user can only answer one
  question per turn. Multi-question gates either get half-answered or dropped entirely.
- **Cryptic option labels.** "Option 1" forces re-reading the context. "Merge into
  existing page" is self-explanatory.
- **Asking about low-stakes decisions.** If the wrong answer costs nothing, just pick
  the best option and mention it. Reserve gates for forks where rework is expensive.

## Output Format

The skill's "output" is the choice-gate message itself, structured as:

```
{emoji-prefix} **{question}**

{1-3 lines of context}

1. **{Option A label}** — {short qualifier}
2. **{Option B label}** — {short qualifier}
3. **{Skip / Cancel}** — {what skipping means}
```

After emitting this, the skill stops the turn. No further tool calls, no
preemptive action, no follow-up message until the user responds. The
user's response triggers the next turn, where the calling skill branches
on the chosen option.

## Dónde encaja

- Categoría: [Automatización](https://skillsagentes.com/categorias/automatizacion.md) — Flujos de varios pasos que se ejecutan sin supervisión.
- Creador: [garrytan](https://skillsagentes.com/creators/garrytan.md) — 134 skills en el directorio
- [Todas las skills](https://skillsagentes.com/skills.md)
- [Ranking de instalaciones](https://skillsagentes.com/ranking.md)

## Otras skills del mismo repositorio

- [Setup](https://skillsagentes.com/skills/garrytan/gbrain/setup.md): Configura GBrain con auto-aprovisionamiento de Supabase o PGLite, inyección en AGENTS.md y primera importación.
- [Maintain](https://skillsagentes.com/skills/garrytan/gbrain/maintain.md): Chequeos de salud del brain: aplicación de back-links, auditoría de citas, validación de filing, detección de info obsoleta, páginas huérfanas y benchmarks.
- [Schema Unify](https://skillsagentes.com/skills/garrytan/gbrain/schema-unify.md): Migra un brain de gbrain-base a la taxonomía de 14 tipos canónicos de gbrain-base-v2 usando gbrain onboard --check y el handler Minion unify-types.
- [Retrieval Reflex](https://skillsagentes.com/skills/garrytan/gbrain/retrieval-reflex.md): Cuándo y qué recuperar: abre la página del brain de una entidad relevante antes de responder desde memoria.
- [Minion Orchestrator](https://skillsagentes.com/skills/garrytan/gbrain/minion-orchestrator.md): Skill unificado de Minions para jobs deterministas de shell y orquestación de subagentes LLM: cola durable, observable y controlable, más la doctrina de ejecución durable para operaciones largas.

---

Skills Agentes · [Índice de páginas en markdown](https://skillsagentes.com/sitemap.md) · [Inicio](https://skillsagentes.com/index.md)