[Feature]: Guided SDD entry point — single intent to full workflow (speckit.go)

### Problem Statement

### Problem Statement

**Goal:** reduce onboarding friction so a new user can drive a first feature through SDD with **one known entry point** instead of memorizing 7+ slash commands and when to use each optional step.

Spec Kit's SDD workflow is powerful but has a steep learning curve:

1. The [README quick start](https://github.com/github/spec-kit/blob/main/README.md) teaches **seven manual slash-command steps** (`/speckit.constitution` → `specify` → `plan` → `tasks` → `implement`, plus optional `clarify` / `analyze`).
2. The **workflow engine** (`specify workflow run speckit`) already orchestrates part of the cycle, but it is easy to miss, does not include `constitution` / `clarify` / `analyze` in the bundled workflow, and is CLI-centric rather than a single agent-facing entry point.
3. **Handoffs** in command frontmatter help in some IDEs but still require the user to click through each transition manually.
4. Community extensions (Fleet, Conduct, Onboard, agent-orchestrator) and [Community Friends](https://github.github.io/spec-kit/community/friends/) (Spec Kit Assistant, SpecKit Companion) address pieces of this, but there is no **official, lightweight, opt-in "start here" path** in core that maps one user intent ("build X") to the right command sequence.

This gap shows up in roadmap themes ("experience simplification", end-to-end automation — see newsletters and related discussion in #1966, #1192) and in external reviews citing ceremony/overhead.

Per [CONTRIBUTING.md](https://github.com/github/spec-kit/blob/main/CONTRIBUTING.md), I'd like to **align on direction here before opening a PR**, since this touches templates and possibly CLI UX.

---

### Proposal

Add an **optional guided entry facade** (composition layer) on top of existing Spec Kit commands/skills and the `WorkflowEngine`.

**This is not a new SDD engine.** The entry layer does **not** implement specify/plan/tasks/implement logic itself. It only:

- Accepts user intent in natural language
- Inspects project state (artifacts, active feature, missing constitution, etc.)
- **Dispatches** to already-installed Spec Kit **commands or skills** for the active integration (e.g. `/speckit.specify`, `/speckit.plan`, or the equivalent skill names in Codex/Cursor skills mode)
- Decides **order**, **when to pause**, and **when to resume** mid-flow
- Defers all phase behavior, scripts, hooks, and artifact formats to the existing commands

Power users keep full control via individual `/speckit.*` commands, presets (`lean`), extensions, and custom workflows.

#### Architecture (facade over existing commands)

```mermaid
flowchart TB
User["User intent"] --> Entry["/speckit.go or specify run"]
Entry --> Facade["Guided entry facade"]
Facade --> Router["State detection + path selection"]
Router --> C1["/speckit.constitution"]
Router --> C2["/speckit.specify"]
Router --> C3["/speckit.clarify optional"]
Router --> C4["/speckit.plan"]
Router --> C5["/speckit.tasks"]
Router --> C6["/speckit.analyze optional"]
Router --> C7["/speckit.implement"]
C1 --> Artifacts["Existing specs/ scripts / hooks"]
C2 --> Artifacts
C4 --> Artifacts
C5 --> Artifacts
C7 --> Artifacts
Facade -.->|"CLI path"| WFE["WorkflowEngine speckit-full"]
WFE -.->|"dispatches same commands"| C2
```

| Layer | Responsibility |
|-------|----------------|
| **Guided entry facade** (`/speckit.go`, optional `specify run`) | Routing, sequencing, pause/resume, onboarding-oriented defaults |
| **Existing `/speckit.*` commands / skills** | All SDD phase logic and artifacts (unchanged) |
| **WorkflowEngine** (optional CLI complement) | Same sequence with persisted runs and review gates via `specify workflow run` |

**User-facing entry (agent):**

- New optional command: `/speckit.go` (name open to discussion — alternatives: `speckit.pipeline`, `speckit.run`)
- Input: natural-language feature intent, e.g. `Build a photo album organizer with drag-and-drop`
- Behavior:
- Inspect project state (e.g. missing `memory/constitution.md`, active feature under `specs/`, existing artifacts)
- Select the appropriate path (full SDD vs lean vs resume mid-flow)
- **Invoke** existing commands/skills in order (via the agent's native slash-command or skill mechanism), pausing only when a step genuinely needs user input (clarification questions, critical analyze findings, review gates)
- Preserve all artifacts under `specs/` and existing scripts/hooks — no parallel artifact model

**User-facing entry (CLI, optional complement):**

- `specify run ""` as a documented alias for running an extended catalog workflow with the same inputs (reusing `specify workflow run`, not a parallel execution engine)

**Workflow complement:**

- Extend or add a catalog workflow (e.g. `speckit-full`) that builds on [`workflows/speckit/workflow.yml`](https://github.com/github/spec-kit/blob/main/workflows/speckit/workflow.yml):
- Optional `constitution` when missing
- `specify` → optional `clarify` → `plan` → `tasks` → optional `analyze` → `implement`
- Reuse existing human review gates where appropriate

---

### Non-Goals

- **Not** a heavy multi-agent orchestrator (Fleet / Conduct style coordination files)
- **Not** reimplementing SDD phases inside the entry command (no mega-prompt that replaces `specify.md` / `plan.md` / etc.)
- **Not** replacing `/speckit.*` or the modular extension/preset model
- **Not** silent auto-trigger on every chat message in core (opt-in explicit invocation preferred for predictability and token cost)
- **Not** duplicating VS Code Friends (Assistant / Companion) — core should stay agent-agnostic; documentation cross-links are fine

---

### Prior Art (in-repo and community)

| Area | Reference |
|------|-----------|
| Prior pipeline proposal | #1966 (closed; proposed `/speckit.pipeline` meta-command) |
| User-built phase runner | #1192 (closed; `orchestrator/run_phase.py` pattern) |
| Built-in partial workflow | `workflows/speckit/workflow.yml` (`specify` → `plan` → `tasks` → `implement`) |
| Ceremony reduction | `presets/lean/` |
| Workflow engine | `src/specify_cli/workflows/engine.py` |
| Community onboarding / routing | Onboard, Intelligent Agent Orchestrator, Fleet Orchestrator extensions |
| Visual orchestration | Spec Kit Assistant, SpecKit Companion (Friends) |

---

### Proposed MVP (after maintainer agreement)

1. `templates/commands/go.md` — facade command: state detection + ordered **dispatch** to existing commands/skills (no new phase templates)
2. `workflows/speckit-full/workflow.yml` (or extend `speckit`) — CLI complement: full cycle with conditional optional steps, same dispatch targets as today
3. Docs: README / docs site — "Quick path" (one entry) vs "Advanced path" (individual `/speckit.*`, lean preset, custom workflows)
4. Tests: workflow loading/validation in `tests/test_workflows.py`

I am happy to submit a **focused MVP PR** once the preferred shape (facade command vs workflow-only, core vs extension catalog, constitution handling) is agreed.

---

### Open Questions for Maintainers

1. **Surface area:** Agent meta-command only, CLI workflow only, or both?
2. **Command name:** `speckit.go`, `speckit.pipeline`, or something else?
3. **Constitution:** Required in the default guided path, optional when missing, or always manual?
4. **Shipping vehicle:** Bundled in core vs community extension first?
5. **Friends overlap:** Document alongside Assistant/Companion, or integrate/reference explicitly?
6. **Auto-trigger:** Should core support any implicit routing, or stay strictly opt-in?

---

### Component

- [ ] CLI (`specify`)
- [x] Templates / commands
- [ ] Workflows
- [ ] Documentation
- [ ] Other

---

### AI Disclosure

- [ ] I did **not** use AI assistance for this issue
- [x] I **did** use AI assistance (describe below)

This issue was drafted with AI assistance for structure and wording; the problem framing, proposal scope, and willingness to implement an MVP are my own.

### Proposed Solution

Add an **optional guided entry facade** (composition layer) on top of existing Spec Kit commands/skills and the `WorkflowEngine` — **not** a new SDD engine.

**What it does (facade only):**
- Accepts one natural-language intent (e.g. “Build a photo album organizer with drag-and-drop”)
- Inspects project state (constitution present?, active feature under `specs/`, existing artifacts)
- **Dispatches** to already-installed `/speckit.*` commands or skills for the active integration, in the right order
- Pauses only when a step needs human input (clarify, critical analyze, review gates)
- Does **not** reimplement specify/plan/tasks/implement logic

**User-facing entry points:**
1. **Agent:** `/speckit.go` (name open to discussion) — single slash command for onboarding
2. **CLI (optional):** `specify run ""` as an alias over `specify workflow run` (no parallel engine)

**Workflow complement:** catalog workflow `speckit-full` extending [`workflows/speckit/workflow.yml`](https://github.com/github/spec-kit/blob/main/workflows/speckit/workflow.yml) with optional `constitution`, `clarify`, and `analyze`.

```mermaid
flowchart TB
User["User intent"] --> Entry["/speckit.go or specify run"]
Entry --> Facade["Guided entry facade"]
Facade --> Router["State detection + path selection"]
Router --> Commands["Existing /speckit.* commands & skills"]
Commands --> Artifacts["specs/ scripts hooks"]

### Alternatives Considered

_No response_

### Component

Specify CLI (initialization, commands)

### AI Agent (if applicable)

None

### Use Cases

_No response_

### Acceptance Criteria

_No response_

### Additional Context

_No response_

Start by resolving the open design questions with maintainers, then read workflows/speckit/workflow.yml, src/specify_cli/workflows/engine.py, and the existing command templates. Compare the proposed MVP with tests/test_workflows.py and existing presets; done requires an agreed scope, an implemented entry path without duplicated phase logic, validated workflow behavior, and corresponding documentation.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.