dceoy/speckit-agent-skills/speckit-clarify

User Input

$ARGUMENTS

You MUST consider the user input before proceeding (if not empty).

Pre-Execution Checks

Check for extension hooks (before clarification):

• Check if .specify/extensions.yml exists in the project root.
• If it exists, read it and look for entries under the hooks.before_clarify key
• If the YAML cannot be parsed or is invalid, do not skip silently: tell the user that .specify/extensions.yml could not be read (include the parser error) and that no hooks were checked, including any mandatory (optional: false) hooks registered there, then continue normally
• Filter out hooks where enabled is explicitly false. Treat hooks without an enabled field as enabled by default.
• For each remaining hook, do not attempt to interpret or evaluate hook condition expressions:
• If the hook has no condition field, or it is null/empty, treat the hook as executable
• If the hook defines a non-empty condition, skip the hook and leave condition evaluation to the HookExecutor implementation
• When constructing command invocations from hook command names, replace dots (.) with hyphens (-). For example, speckit.git.commit → /speckit-git-commit.
• For each executable hook, output the following based on its optional flag:
• Optional hook (optional: true):

```text ## Extension Hooks

Optional Pre-Hook: {extension} Command: /{command} Description: {description}

Prompt: {prompt} To execute: /{command} ```

• Mandatory hook (optional: false):

```text ## Extension Hooks

Automatic Pre-Hook: {extension} Executing: /{command} EXECUTE_COMMAND: {command}

Wait for the result of the hook command before proceeding to the Outline. ```

After emitting the block above you MUST actually invoke the hook and wait for it to finish before continuing. Run it the same way you would run the command yourself in this agent/session (the invocation may differ from the literal {command} id shown above, e.g. a skills-mode agent runs it as /skill:speckit-... or $speckit-...). Emitting the block alone does not run the hook.

• If no hooks are registered or .specify/extensions.yml does not exist, skip silently

Outline

Goal: Detect and reduce ambiguity or missing decision points in the active feature specification and record the clarifications directly in the spec file.

Note: This clarification workflow is expected to run (and be completed) BEFORE invoking /speckit-plan. If the user explicitly states they are skipping clarification (e.g., exploratory spike), you may proceed, but must warn that downstream rework risk increases.

Execution steps:

1. Run .specify/scripts/bash/check-prerequisites.sh --json --paths-only from repo root once (combined --json --paths-only mode / -Json -PathsOnly). Parse minimal JSON payload fields:

• FEATURE_DIR
• FEATURE_SPEC
• (Optionally capture IMPL_PLAN, TASKS for future chained flows.)
• If JSON parsing fails, abort and instruct user to re-run /speckit-specify or verify feature branch environment.
• For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").

1. IF EXISTS: Load .specify/memory/constitution.md for project principles and governance constraints.

1. Load the current spec file. Perform a structured ambiguity & coverage scan using this taxonomy. For each category, mark status: Clear / Partial / Missing. Produce an internal coverage map used for prioritization (do not output raw map unless no questions will be asked).

Functional Scope & Behavior:

• Core user goals & success criteria
• Explicit out-of-scope declarations
• User roles / personas differentiation

Domain & Data Model:

• Entities, attributes, relationships
• Identity & uniqueness rules
• Lifecycle/state transitions
• Data volume / scale assumptions

Interaction & UX Flow:

• Critical user journeys / sequences
• Error/empty/loading states
• Accessibility or localization notes

Non-Functional Quality Attributes:

• Performance (latency, throughput targets)
• Scalability (horizontal/vertical, limits)
• Reliability & availability (uptime, recovery expectations)
• Observability (logging, metrics, tracing signals)
• Security & privacy (authN/Z, data protection, threat assumptions)
• Compliance / regulatory constraints (if any)

Integration & External Dependencies:

• External services/APIs and failure modes
• Data import/export formats
• Protocol/versioning assumptions

Edge Cases & Failure Handling:

• Negative scenarios
• Rate limiting / throttling
• Conflict resolution (e.g., concurrent edits)

Constraints & Tradeoffs:

• Technical constraints (language, storage, hosting)
• Explicit tradeoffs or rejected alternatives

Terminology & Consistency:

• Canonical glossary terms
• Avoided synonyms / deprecated terms

Completion Signals:

• Acceptance criteria testability
• Measurable Definition of Done style indicators

Misc / Placeholders:

• TODO markers / unresolved decisions
• Ambiguous adjectives ("robust", "intuitive") lacking quantification

For each category with Partial or Missing status, add a candidate question opportunity unless:

• Clarification would not materially change implementation or validation strategy
• The item is specifically about implementation method, tech-stack comparison, or task breakdown (note internally)

1. Generate (internally) a prioritized queue of candidate clarification questions (maximum 5). Do NOT output them all at once. Apply these constraints:

• Maximum of 5 total questions across the whole session.
• Each question must be answerable with EITHER:
• A short multiple‑choice selection (2–5 distinct, mutually exclusive options), OR
• A one-word / short‑phrase answer (explicitly constrain: "Answer in <=5 words").
• Only include questions whose answers materially impact architecture, data modeling, task decomposition, test design, UX behavior, operational readiness, or compliance validation.
• Ensure category coverage balance: attempt to cover the highest impact unresolved categories first; avoid asking two low-impact questions when a single high-impact area (e.g., security posture) is unresolved.
• Exclude questions already answered, trivial stylistic preferences, or plan-level execution details (unless blocking correctness).
• Favor clarifications that reduce downstream rework risk or prevent misaligned acceptance tests.
• If more than 5 categories remain unresolved, select the top 5 by (Impact * Uncertainty) heuristic.

1. Sequential questioning loop (interactive):

• Present EXACTLY ONE question at a time.
• Question writing quality (applies to every question, MC or short-answer):
• Lead with **Question:** followed by a full interrogative that ends with ?. The question text before the ? must make sense on its own.
• NEVER use a topic label, section heading, or requirement id as the question itself. For example, Acceptance device/runtime matrix (FR-023) is INVALID — it is a label, not a question.
• After the ?, the only permitted suffix is an optional parenthesized requirement/question id. Exact format: **Question:** <interrogative>? or **Question:** <interrogative>? (FR-023). Never put the id before the ?, and never use the id (alone or with a topic label) as the whole prompt.
• Immediately after the question line, add one plain-language "Why it matters" sentence (the stake for acceptance or shipping) before the recommendation/options.
• Use everyday wording; introduce jargon only if defined in the same sentence. Self-check: a reader who does not know Spec Kit must be able to answer from the Question line alone. Terse is fine; cryptic labels are not.
• For multiple‑choice questions:
• Analyze all options and determine the most suitable option based on:
• Best practices for the project type
• Common patterns in similar implementations
• Risk reduction (security, performance, maintainability)
• Alignment with any explicit project goals or constraints visible in the spec
• Present your recommended option prominently at the top with clear reasoning (1-2 sentences explaining why this is the best choice).
• Format as: **Recommended:** Option [X] - <reasoning>
• Then render all options as a Markdown table:

<!-- markdownlint-disable MD058 -->

<!-- markdownlint-enable MD058 -->

• After the table, add: You can reply with the option letter (e.g., "A"), accept the recommendation by saying "yes" or "recommended", or provide your own short answer.

• For short‑answer style (no meaningful discrete options):
• Provide your suggested answer based on best practices and context.
• Format as: **Suggested:** <your proposed answer> - <brief reasoning>
• Then output: Format: Short answer (<=5 words). You can accept the suggestion by saying "yes" or "suggested", or provide your own answer.
• After the user answers:
• If the user replies with "yes", "recommended", or "suggested", use your previously stated recommendation/suggestion as the answer.
• Otherwise, validate the answer maps to one option or fits the <=5 word constraint.
• If ambiguous, ask for a quick disambiguation (count still belongs to same question; do not advance).
• Once satisfactory, record it in working memory (do not yet write to disk) and move to the next queued question.
• Stop asking further questions when:
• All critical ambiguities resolved early (remaining queued items become unnecessary), OR
• User signals completion ("done", "good", "no more"), OR
• You reach 5 asked questions.
• Never reveal future queued questions in advance.
• If no valid questions exist at start, immediately report no critical ambiguities.