"I'll help you estimate a work item. What would you like to estimate?

A) Specific item: {ITEM_ID or ITEM_TITLE}
B) Multiple items from backlog
C) Items in current sprint
D) All unestimated items in project

[If user selects A, fetch item details. Otherwise, list items for selection]"

"Let me analyze this story for estimation:

**Story:** {STORY_TITLE}
**Description:** {STORY_DESCRIPTION}

**Questions to consider:**
1. **Scope:** How much work is involved?
   - Small feature (1-2 endpoints/components)
   - Medium feature (3-5 endpoints/components)
   - Large feature (6+ endpoints/components)

2. **Complexity:** How complex is the implementation?
   - Straightforward (similar to existing code)
   - Moderate (some new patterns/concepts)
   - Complex (new architecture, significant research)

3. **Dependencies:** What dependencies exist?
   - None (can start immediately)
   - Some (waiting on 1-2 items)
   - Many (waiting on multiple items)

4. **Risk:** What's the risk level?
   - Low (well-understood, low uncertainty)
   - Medium (some unknowns, manageable)
   - High (significant unknowns, high uncertainty)

5. **Testing:** How much testing is needed?
   - Unit tests only
   - Unit + integration tests
   - Unit + integration + E2E tests

Based on these factors, I'll suggest a story point estimate."

"Let me analyze this task for estimation:

**Task:** {TASK_TITLE}
**Description:** {TASK_DESCRIPTION}
**Type:** {TASK_TYPE}

**Estimation factors:**
- Scope and complexity
- Technical difficulty
- Dependencies and blockers
- Testing requirements
- Documentation needs

I'll suggest an estimate based on these factors."

def estimate_item(scope, complexity, dependencies, risk, testing):
    base_points = {
        "small": 2,
        "medium": 5,
        "large": 8
    }
    
    points = base_points[scope]
    
    # Adjust for complexity
    if complexity == "complex":
        points += 3
    elif complexity == "moderate":
        points += 1
    
    # Adjust for risk
    if risk == "high":
        points += 2
    elif risk == "medium":
        points += 1
    
    # Adjust for dependencies
    if dependencies == "many":
        points += 1
    
    # Adjust for testing
    if testing == "comprehensive":
        points += 1
    
    # Round to Fibonacci sequence
    return round_to_fibonacci(points)

"Based on my analysis, I suggest:

**Suggested Estimate:** {POINTS} story points

**Reasoning:**
- Scope: {SCOPE_ASSESSMENT} ({SCOPE_POINTS} points)
- Complexity: {COMPLEXITY_ASSESSMENT} ({COMPLEXITY_ADJUSTMENT})
- Risk: {RISK_ASSESSMENT} ({RISK_ADJUSTMENT})
- Dependencies: {DEPENDENCY_ASSESSMENT} ({DEPENDENCY_ADJUSTMENT})
- Testing: {TESTING_ASSESSMENT} ({TESTING_ADJUSTMENT})

**Estimation Range:** {MIN_POINTS} - {MAX_POINTS} points
(If team velocity suggests different, adjust accordingly)

Would you like to:
A) Apply this estimate ({POINTS} points)
B) Adjust estimate ({NEW_POINTS} points)
C) Skip estimation for now
D) Compare with similar items"

"Let me find similar items for comparison:

**Similar Items:**
- {ITEM_1}: {ESTIMATE} points (completed)
- {ITEM_2}: {ESTIMATE} points (completed)
- {ITEM_3}: {ESTIMATE} points (in progress)

**Average for similar items:** {AVG_POINTS} points

**Your item complexity vs. similar:**
- {COMPARISON_ASSESSMENT}

**Adjusted suggestion:** {ADJUSTED_POINTS} points

{
  "itemId": "{ITEM_ID}",
  "status": "{CURRENT_STATUS}", // preserve status
  "estimate": "{POINTS}" // add estimate field
}

{
  "itemId": "{ITEM_ID}",
  "estimate": "{POINTS}"
}

"✅ Estimate applied successfully!

**Item:** {ITEM_TITLE}
**Estimate:** {POINTS} story points
**Previous Estimate:** {PREVIOUS_ESTIMATE or "None"}

**Estimation Notes:**
{REASONING_SUMMARY}

**Next Steps:**
1. Review estimate: {BACKEND_URL}
2. Use in sprint planning (team velocity: {VELOCITY} points/sprint)
3. Track actual vs. estimated after completion
4. Adjust future estimates based on learnings

Estimate is ready for planning!"

✅ Estimate applied successfully!

**Item:** User Authentication (STORY-101)
**Estimate:** 5 story points
**Previous Estimate:** None

**Estimation Notes:**
Medium scope feature with moderate complexity and comprehensive testing requirements.

**Next Steps:**
1. Review estimate: https://company.atlassian.net/browse/STORY-101
2. Use in sprint planning (team velocity: 20 points/sprint)
3. Track actual vs. estimated after completion

✅ Estimate applied successfully!

**Item:** Implement Payment Gateway Integration (TASK-201)
**Estimate:** 8 story points
**Previous Estimate:** None

**Estimation Notes:**
Large scope task with high complexity (external API integration), some risk (payment handling), and comprehensive testing needs.

**Next Steps:**
1. Review estimate: https://linear.app/team/task/201
2. Consider breaking into smaller tasks if too large
3. Track actual time vs. estimate

**Similar Items Found:**
- STORY-045: User Profile View (3 points, completed)
- STORY-067: User Settings Update (5 points, completed)
- STORY-089: User Preferences (3 points, in progress)

**Average for similar items:** 3.7 points

**Your Story:** User Profile Edit
**Complexity vs. similar:** More complex (includes validation, image upload)

**Suggested Estimate:** 5 story points

✅ Estimate applied successfully!

**Item:** User Profile Edit (STORY-102)
**Estimate:** 5 story points

"Would you like to estimate this story now?
I can help you assign story points using the estimate-task skill."

"When planning sprints, I can:
1. Show total estimated points for selected stories
2. Compare against team velocity
3. Warn if sprint is over/under capacity"

"When closing sprints, I can:
1. Compare estimated vs. actual points
2. Calculate team velocity
3. Identify estimation patterns for improvement"

# Estimate item via CLI (if implemented)
python cli/factory_cli.py --estimate-item \
  --item-id "STORY-101" \
  --points "5"

# List unestimated items
python cli/factory_cli.py --list-items --project-id "PROJ-123" --unestimated

# Compare estimates
python cli/factory_cli.py --compare-estimates --item-id "STORY-101"