version: "1.0.1" name: new-task description: Trigger when 유저가 뭔가 일을 시키거나, 하이 레벨 컨셉을 이야기 할 경우, 유저의 지시에 여러 가지 암묵지가 느껴질 경우.

Desc: Transform vague user requirements into STV-structured feature specs with traced scenarios. Orchestrates stv:spec and stv:trace to produce implementable work.

New Task — STV Feature Decomposition

Overview

new-task transforms vague user requirements into structured STV artifacts (spec.md + trace.md) with traced scenarios as the task list.

Core principle: Understand intent deeply → Create spec via stv:spec → Create trace via stv:trace → trace.md scenarios = task list.

When to Use

Use when:

• User describes feature/idea in vague or high-level terms
• Need to decompose work into implementable scenarios
• Architectural decisions required before implementation
• Multiple implementation approaches possible
• Work requires structured spec + trace before coding

Do NOT use when:

• User request is already specific (1-2 file changes)
• Fixing obvious bug with clear solution
• Quick clarification or simple question
• Spec and trace already exist (use stv:do-work directly)

Sizing Rubric

Workflow Phases

Phase 1: Intent Understanding
    ↓
Phase 2: Spec Creation (→ stv:spec)
    ↓
Phase 3: Trace Creation (→ stv:trace)
    ↓
Phase 4: Summary & Next Steps

Phase 1: Intent Understanding (~5min)

Goal: Ground the vague request in actual project context.

1. Analyze user request

• Identify core intent
• Extract implicit requirements
• Estimate scope

1. Explore codebase (Agent:Explore)

• Identify related existing code
• Understand existing patterns, conventions, architecture
• Check if similar features already exist
• Map affected areas

1. Summarize context

• Organize discovered code/patterns
• Identify integration points with existing architecture
• Prepare information for spec interview in Phase 2

Phase 2: Spec Creation → Invoke stv:spec

Goal: Generate a structured spec.md.

Skill(skill="stv:spec") invoked

• Conduct spec interview based on context collected in Phase 1
• Apply Decision Gate: switching cost < small → autonomous judgment, >= medium → ask user
• Output: docs/{feature}/spec.md

Phase 3: Trace Creation → Invoke stv:trace

Goal: Decompose spec into per-scenario vertical traces + RED contract tests.

Skill(skill="stv:trace") invoked

• Trace per-scenario call stacks using spec.md as input
• Derive contract tests for each scenario
• Output: docs/{feature}/trace.md + RED tests

Phase 4: Summary & Next Steps (~2min)

Goal: Present overall results to the user + execution guidance.

1. trace.md scenario list = task list

• Each scenario in the Implementation Status table is one work unit

1. Present summary to user

## Feature Ready: {feature-name}
 
### Artifacts Created
-`docs/{feature}/spec.md` — PRD + Architecture
-`docs/{feature}/trace.md` — {N} scenarios traced
-{N} RED contract tests created
 
### Scenario Task List
| # | Scenario | Size | Status |
|---|----------|------|--------|
| 1 | {title} | {tier} | Ready |
| 2 | {title} | {tier} | Ready |
| ... | ... | ... | ... |
 
### Auto-Decisions Made
{Summary of items autonomously decided via Decision Gate}
 
### Next Step
→ Start per-scenario implementation with `stv:do-work`
→ Or implement directly with `stv:work docs/{feature}/trace.md`

Integration with Other Skills

INVOKES:

• stv:spec — Spec creation in Phase 2
• stv:trace — Trace creation in Phase 3

SEQUENTIAL: After new-task completes → Use stv:do-work for execution

CALLED BY:

• stv:plan-new-task — Called after proposing a new feature and user selects an idea

Common Mistakes

NEVER

• Skip or abbreviate stv:spec or stv:trace workflows
• Guide implementation without a trace
• Declare "complete" without a scenario list