/ask

description: Ask a single expert agent a question - like a Slack ping to a colleague
argument-hint: "[expert] [question] [--solo]"

Ask an Expert

Quick consultation with a single expert agent. Like pinging a colleague on Slack.

> **IMPORTANT:** If the spec below invokes any deferred tool (e.g. `AskUserQuestion`), you MUST load and call it as specified. Never skip the call, never substitute a default answer of your own — the tool invocation is part of the contract. This is critical.

Usage

/lets:ask                          # Interactive - asks who and what
/lets:ask security "is this safe?" # Direct to expert with question
/lets:ask architect                # Opens dialog, asks question after
/lets:ask ... --solo               # In a team worktree: a one-shot expert, not the team's member

Difference from /lets:opinion

| | /lets:ask | /lets:opinion | |---|---|---| | Purpose | Ask one colleague | Team meeting | | Experts | Always 1 | Dynamic, in parallel | | Input | Question | Decision + options | | Output | Direct answer | Comparison table + recommendation | | Analogy | Slack ping | 30 min meeting |

Step 1: Determine Expert

**Parse the argument:** strip a `--solo` token if present (team mode off - `protocol/agents.md` `## Team mode`; route gets `solo`); the rest names the expert and the question.

If specified in arguments - use it. Otherwise use **AskUserQuestion** to pick.

Available experts (map to `lets:*` agents):

| # | Shorthand | Agent (subagent_type) | Expertise | |---|-----------|----------------------|-----------| | 1 | architect | lets:architect | System design, patterns, SOLID | | 2 | security | lets:security | Vulnerabilities, auth, crypto | | 3 | backend | lets:backend | API, logic, performance | | 4 | frontend | lets:frontend | UI, React/Vue, a11y | | 5 | database | lets:database | Schema, queries, migrations | | 6 | devops | lets:devops | Docker, CI/CD, infrastructure | | 7 | qa | lets:qa | Testing, coverage, strategy | | 8 | docs | lets:docs | Documentation, API docs | | 9 | compliance | lets:compliance | Project rules, standards | | 10 | git-historian | lets:git-historian | History, past decisions, blame | | 11 | pragmatist | lets:pragmatist | ROI, effort vs value, scope | | 12 | actor | lets:actor | External personality - any expertise via loaded persona |

**Shorthand mapping:** User can type short names like "security" or "sec" - map to the correct agent subagent_type.

**Actor handling:** If expert is `actor`, the remaining argument should contain a personality source (URL or file path) followed by the question. Example: `/lets:ask actor https://example.com/persona.md "question"`. Invoke `Skill(skill: "lets:actor-fetch-personality", args: "<personality-source-from-user>")` to fetch and validate the personality. If no source provided, ask via AskUserQuestion: "Personality source? (URL or file path)". Pass fetched content as `PERSONALITY:` block in the Task prompt (see Step 4).

**If no expert specified**, select top 4 most relevant based on conversation context and use **AskUserQuestion**:

AskUserQuestion(
  questions=[{
    question: "Which expert to ask?",
    header: "Expert",
    options: [
      { label: "{expert 1}", description: "{expertise}" },
      { label: "{expert 2}", description: "{expertise}" },
      { label: "{expert 3}", description: "{expertise}" },
      { label: "{expert 4}", description: "{expertise}" }
    ],
    multiSelect: false
  }]
)

**Other** (free text) -> match to expert shorthand from table above.

Step 2: Determine Question

If passed as argument - use it. Otherwise ask the user.

Step 3: Gather Context

Before launching the agent, gather relevant context:

LETS_PROJECT_ROOT=$(git rev-parse --show-toplevel)
cat "$LETS_PROJECT_ROOT/CLAUDE.md" 2>/dev/null | head -100

Also check if the question references specific files - if so, note the file paths for the agent.

Step 4: Launch Agent

Read `${CLAUDE_PLUGIN_ROOT}/protocol/agents.md` before this step unless its text is in your current context.

**Team mode** (`protocol/agents.md` `## Team mode`): `Skill(skill: "lets:member-run", args: "op=route command=ask roles=<the expert, bare> fallback=one-shot")` first (`--solo` adds `solo`). A member gets the ask prompt below as its single item; the Task call is the fallback's.

Open the run: `Skill(skill: "lets:agent-report", args: "op=open command=ask task={task-id} names={agent short name}")` (task omitted when none), then use the Task tool to spawn the selected agent with its REPORT_FILE line:

Task(
  subagent_type="lets:{agent-name}",
  prompt="ultrathink

PROJECT_ROOT: {LETS_PROJECT_ROOT from LETS Config}. Do NOT read or search files outside this directory.
REPORT_FILE: {the agent's path from op=open}

MODE: ask

{If actor agent: include PERSONALITY block from actor-fetch-personality skill}
PERSONALITY:
{fetched personality content - only for lets:actor, omit for other agents}

PROJECT CONTEXT:
{CLAUDE.md summary - stack, conventions, key rules}

QUESTION: {user_question}"
)

Step 5: Present Results

`Skill(skill: "lets:agent-report", args: "op=collect dir={REPORT_DIR} names={agent short name}")`, or for a member `op=receive` - READ EVERY REPORT IN FULL; show the report file's content (without the `REPORT-END` line) under `## {Agent Name} says:`. A `GAP` after the retry -> say plainly that the expert's report did not arrive ({state}); show any final text only marked UNVERIFIED.

Show the agent's response:

## {Agent Name} says:

{agent response}

Step 6: Link Answer to Active Task

Use the **detect-task** skill to find the active task: `Skill(skill: "lets:detect-task")`. If multiple tasks found, skip the tracker comment. If active task found:

**Tracker protocol:** `Skill(skill: "lets:protocol-tracker")` before this and any later `lets-tracker` block here, unless its text is in your current context.

comment-add task=<task-id> body="Ask