Claude Skill

ask-gate

The Ask-Gate Protocol (AGP). Before surfacing an AskUserQuestion, triage whether the question is genuinely the handler's call (anti-nag); ask routine questions directly after a quality checklist, but escalate high-stakes / branching / irreversible ones through /insight-critique t

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download allemaar-open-skills-skills_ask-gate-acf5f79.zip · 6 KB

Install

skills CLI npx skills add https://github.com/allemaar/open-skills/tree/main/skills/ask-gate
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install allemaar-open-skills@llmmart
Git git clone https://github.com/allemaar/open-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole allemaar/open-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

/ask-gate

Ask-Gate (AGP) governs the moment just before a handler-facing question. Asking is cheap to type and expensive to waste — a question the agent could have answered itself is a nag, and a high-stakes question asked with the wrong options or framing burns the one interaction that mattered. AGP makes AskUserQuestion a deliberate, quality-gated reflex instead of a casual reach: triage whether to ask at all, ask routine questions directly after a quick checklist, and escalate the questions that actually matter through /insight-critique then /insight-assess before surfacing them.

AGP is invoked two ways: automatically, as the standard reflex before any AskUserQuestion (it can fire inside COP's surface step, inside NSP's surface step, or standalone); or directly, as /ask-gate to quality-gate a specific pending question.

Structured execution spec: protocol.yon. Read it for the canonical rules and step sequence; this file is explanation. The two must stay in sync — if you edit one, update the other and refresh the @STAMP date.

The protocol — three steps

1. Triage (anti-nag)

Sensible defaults resolve preferences only within existing authority. They never supply missing consent or a required approval. Reuse exact authorization already granted; do not ask for it again. A question is the handler's to answer if required authorization is missing, or if it cannot otherwise be resolved from the request, the code, or sensible defaults within that authority. If it can be resolved, resolve it, state the choice you made, and do not ask. Asking a resolvable question is the single most common nag failure — this gate exists to kill it. This mirrors COP's step-1 anti-nag triage; if nothing genuinely needs the handler, AGP surfaces nothing.

2. Classify stakes

If a question is warranted, classify it:

  • Routine — low-stakes, reversible, one obvious framing (a preference, an NSP "which next skill?", a yes/no with a clear default). → Routine path (3a).
  • High-stakes — architecturally load-bearing, hard to reverse, commits resources or time, or 3+ viable options where the framing itself is uncertain, or the answer shapes a plan/roadmap. → High-stakes path (3b).

When in doubt between the two, treat it as high-stakes — the escalation is cheap relative to a mis-framed expensive decision.

3a. Routine path — inline checklist, then ask

Apply this lightweight question-quality checklist inline, then surface directly:

  • Handler's call? — already confirmed in triage.
  • Mutually exclusive? — single-select options must be mutually exclusive; use multiSelect only when choices genuinely aren't.
  • Recommended-first — put the recommended option first and label it "(Recommended)".
  • Exhaustive enough — options cover the real space; "Other" is the escape hatch, not a substitute for thinking.
  • Self-answerable? — not answerable by gathering a little context yourself first.
  • Within limits — ≤4 options per question, ≤4 questions.

3b. High-stakes path — critique → assess → ask

Before using the high-stakes helpers, load their available current owners and check subject fit. For a general question outside the critique owner’s contract, or an unavailable helper, apply the existing question-quality checklist locally and report the skipped method when material; do not reconstruct a missing protocol or claim that it ran. Use the available domain-appropriate assessment, preserving unresolved consent and all existing action gates. This fallback adds no loop or automatic installation.

  1. /insight-critique the candidate questions themselves (not the underlying work): are these the right questions? Are the options mutually exclusive, exhaustive, recommended-first? Is anything still resolvable without the handler?
  2. /insight-assess the critique findings: which framing and option set best serves the decision? Produce the refined question set.
  3. Ask the refined set via AskUserQuestion, recommended option first.

Both sub-skills run inline under an AG-RESOLVED marker carrying depth: 1 — see Depth & safety.

Depth & safety

  • Depth-1 only. /insight-critique and /insight-assess can themselves surface questions. When AGP invokes them, it prepends an AG-RESOLVED marker with depth: 1; under that marker they run inline and any question they raise is asked directly after the inline checklist — they never re-enter AGP. The marker is the recursion guard (no harness signal detects this nesting).
  • Triage always runs first. Never surface a question that triage can resolve.
  • Escalation is bounded. The high-stakes path runs critique once and assess once — it is not a loop. If the refined questions are still unclear, ask the handler that meta-question directly rather than escalating again.

Lifecycle position

AGP, Caller Options (COP), and Next Skills (NSP) are the three question/handoff hooks and never conflict:

  • COP runs before a skill — routes venue (inline / delegated / fan-out) and mode.
  • NSP runs after a skill — recommends successor skills.
  • AGP wraps the question itself — whenever any of them (or the bare agent) is about to ask the handler something.

AGP can fire inside COP's surface step or NSP's surface step: those protocols decide what to ask; AGP decides whether and how to ask it well.

Platform mapping

  • Surface — Claude Code: AskUserQuestion. Codex or any runtime without a structured-question tool: present the options + recommendation as a numbered prose list and wait for the reply.
  • Triage, classify, critique, assess are runtime-agnostic.

Standalone use

/ask-gate runs the protocol ad-hoc on a specific pending question — useful to quality-gate a question you've already drafted, or to smoke-test the triage on a borderline "should I even ask this?" case.

Boundary

Not a session mode and not a router for skills. For venue/mode routing of a skill invocation use caller-options; for successor-skill recommendations use next-skills. AGP uses insight-critique and insight-assess on the high-stakes path — it does not replace them.

Human output. This skill's handler-facing output obeys the human-output contract (human-output/SKILL.md).

Self-improvement. On completion, run the Self-Improvement Protocol (self-improve/SKILL.md): apply its signal taxonomy and threshold to this run; surface any surviving proposal for handler approval. Conservative — silent otherwise. Never auto-apply.

Files (open-skills)
  • protocol.yon 6.9 KB · in bundle
  • SKILL.md 7.8 KB
    ---
    name: ask-gate
    description: >
      The Ask-Gate Protocol (AGP). Before surfacing an AskUserQuestion, triage whether the question is genuinely the handler's call (anti-nag); ask routine questions directly after a quality checklist, but escalate high-stakes / branching / irreversible ones through /insight-critique then /insight-assess first. Trigger via /ask-gate, or automatically before any handler-facing question. Not /caller-options (routes a skill's venue/mode) or /next-skills (recommends successors) — AGP governs the question itself.
    visibility: public
    self-improvable: true
    triggers:
      - "/ask-gate"
    next-skills:
      - skill: insight-cross-examine
        phrase: "/insight-cross-examine"
        why: "When triage escalates a high-stakes branching question, deliberate the options to a recommendation before asking."
      - skill: insight-assess
        phrase: "/insight-assess"
        why: "Evaluate the specific options behind an escalated decision so the handler's call is grounded."
      - skill: reflect
        phrase: "/reflect"
        why: "If the question is the handler's but you want to surface your own assumptions first, pause before phrasing it."
    ---
    
    # /ask-gate
    
    **Ask-Gate (AGP)** governs the moment *just before* a handler-facing question. Asking is cheap to type and expensive to waste — a question the agent could have answered itself is a nag, and a high-stakes question asked with the wrong options or framing burns the one interaction that mattered. AGP makes AskUserQuestion a deliberate, quality-gated reflex instead of a casual reach: triage whether to ask at all, ask routine questions directly after a quick checklist, and escalate the questions that actually matter through `/insight-critique` then `/insight-assess` before surfacing them.
    
    AGP is invoked two ways: **automatically**, as the standard reflex before any AskUserQuestion (it can fire inside COP's surface step, inside NSP's surface step, or standalone); or **directly**, as `/ask-gate` to quality-gate a specific pending question.
    
    > **Structured execution spec:** [`protocol.yon`](protocol.yon). Read it for the canonical rules and step sequence; this file is explanation. The two must stay in sync — if you edit one, update the other and refresh the `@STAMP` date.
    
    ## The protocol — three steps
    
    ### 1. Triage (anti-nag)
    
    Sensible defaults resolve preferences only within existing authority. They never supply missing consent or a required approval. Reuse exact authorization already granted; do not ask for it again. A question is the handler's to answer **if required authorization is missing, or if it cannot otherwise be resolved from the request, the code, or sensible defaults within that authority.** If it can be resolved, resolve it, state the choice you made, and **do not ask**. Asking a resolvable question is the single most common nag failure — this gate exists to kill it. This mirrors COP's step-1 anti-nag triage; if nothing genuinely needs the handler, AGP surfaces nothing.
    
    ### 2. Classify stakes
    
    If a question is warranted, classify it:
    
    - **Routine** — low-stakes, reversible, one obvious framing (a preference, an NSP "which next skill?", a yes/no with a clear default). → **Routine path** (3a).
    - **High-stakes** — architecturally load-bearing, hard to reverse, commits resources or time, *or* 3+ viable options where the *framing itself* is uncertain, *or* the answer shapes a plan/roadmap. → **High-stakes path** (3b).
    
    When in doubt between the two, treat it as high-stakes — the escalation is cheap relative to a mis-framed expensive decision.
    
    ### 3a. Routine path — inline checklist, then ask
    
    Apply this lightweight question-quality checklist inline, then surface directly:
    
    - **Handler's call?** — already confirmed in triage.
    - **Mutually exclusive?** — single-select options must be mutually exclusive; use `multiSelect` only when choices genuinely aren't.
    - **Recommended-first** — put the recommended option first and label it "(Recommended)".
    - **Exhaustive enough** — options cover the real space; "Other" is the escape hatch, not a substitute for thinking.
    - **Self-answerable?** — not answerable by gathering a little context yourself first.
    - **Within limits** — ≤4 options per question, ≤4 questions.
    
    ### 3b. High-stakes path — critique → assess → ask
    
    Before using the high-stakes helpers, load their available current owners and check subject fit. For a general question outside the critique owner’s contract, or an unavailable helper, apply the existing question-quality checklist locally and report the skipped method when material; do not reconstruct a missing protocol or claim that it ran. Use the available domain-appropriate assessment, preserving unresolved consent and all existing action gates. This fallback adds no loop or automatic installation.
    
    1. **`/insight-critique`** the *candidate questions themselves* (not the underlying work): are these the right questions? Are the options mutually exclusive, exhaustive, recommended-first? Is anything still resolvable without the handler?
    2. **`/insight-assess`** the critique findings: which framing and option set best serves the decision? Produce the refined question set.
    3. **Ask** the refined set via AskUserQuestion, recommended option first.
    
    Both sub-skills run **inline under an `AG-RESOLVED` marker carrying `depth: 1`** — see Depth & safety.
    
    ## Depth & safety
    
    - **Depth-1 only.** `/insight-critique` and `/insight-assess` can themselves surface questions. When AGP invokes them, it prepends an `AG-RESOLVED` marker with `depth: 1`; under that marker they run inline and any question they raise is asked directly after the inline checklist — they never re-enter AGP. The marker *is* the recursion guard (no harness signal detects this nesting).
    - **Triage always runs first.** Never surface a question that triage can resolve.
    - **Escalation is bounded.** The high-stakes path runs critique once and assess once — it is not a loop. If the refined questions are still unclear, ask the handler that meta-question directly rather than escalating again.
    
    ## Lifecycle position
    
    AGP, **Caller Options (COP)**, and **Next Skills (NSP)** are the three question/handoff hooks and never conflict:
    
    - **COP** runs *before* a skill — routes venue (inline / delegated / fan-out) and mode.
    - **NSP** runs *after* a skill — recommends successor skills.
    - **AGP** wraps *the question itself* — whenever any of them (or the bare agent) is about to ask the handler something.
    
    AGP can fire inside COP's surface step or NSP's surface step: those protocols decide *what* to ask; AGP decides *whether and how* to ask it well.
    
    ## Platform mapping
    
    - **Surface** — Claude Code: `AskUserQuestion`. Codex or any runtime without a structured-question tool: present the options + recommendation as a numbered prose list and wait for the reply.
    - **Triage, classify, critique, assess** are runtime-agnostic.
    
    ## Standalone use
    
    `/ask-gate` runs the protocol ad-hoc on a specific pending question — useful to quality-gate a question you've already drafted, or to smoke-test the triage on a borderline "should I even ask this?" case.
    
    ## Boundary
    
    Not a session mode and not a router for skills. For venue/mode routing of a skill invocation use [`caller-options`](../caller-options/SKILL.md); for successor-skill recommendations use [`next-skills`](../next-skills/SKILL.md). AGP *uses* [`insight-critique`](../insight-critique/SKILL.md) and [`insight-assess`](../insight-assess/SKILL.md) on the high-stakes path — it does not replace them.
    
    > **Human output.** This skill's handler-facing output obeys the human-output
    > contract (`human-output/SKILL.md`).
    
    > **Self-improvement.** On completion, run the Self-Improvement Protocol (`self-improve/SKILL.md`): apply its signal taxonomy and threshold to this run; surface any surviving proposal for handler approval. Conservative — silent otherwise. Never auto-apply.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.