fraim-framework 2.0.65 → 2.0.67

package/dist/registry/workflows/customer-development/insight-triage.md

@@ -0,0 +1,933 @@
+# Customer Insight Triage Workflow
+
+## INTENT
+To systematically convert customer pain points, feature requests, and insights from interview analysis documents into prioritized GitHub issues, ensuring customer needs drive product development while maintaining traceability from customer to implementation.
+
+## PRINCIPLES
+- **Customer-Driven Development**: Every issue traces back to specific customer requests
+- **Smart Deduplication**: Avoid creating duplicate issues, instead enhance existing ones with customer context
+- **Prioritization Intelligence**: Use customer fit scores, urgency, and number of requesting customers to prioritize
+- **Traceability**: Maintain clear links between customers and features via issue comments
+- **Pattern Recognition**: Process multiple interview analyses at once to identify cross-customer patterns
+- **Batch Efficiency**: Consolidate similar requests before creating issues
+
+## WORKFLOW TRIGGER
+**PM explicitly starts this workflow**:
+- "Starting Customer Insight Triage for [Customer Name(s)]"
+- "Triage the interview analysis for [Customer Name]"
+- "Convert [Customer Name]'s insights into GitHub issues"
+- "Following the customer insight triage workflow"
+- "Triage all recent interviews" (processes multiple at once)
+
+## INPUT REQUIREMENTS
+**PM provides**:
+- One or more interview analysis files (e.g., `ronil-dhruva-interview-analysis.md`, `sanjoy-ghosh-interview-analysis.md`)
+- OR: Glob pattern like `docs/customer-development/*-interview-analysis.md` to process all
+- Optional: Priority level override
+- Optional: Target milestone/sprint
+- Optional: Date range filter for "recent" interviews
+
+**Note**: If PM provides raw interview notes instead of analysis file, workflow will automatically call the insight-analysis workflow first.
+
+## AI AGENT PROCESS
+
+### Step 1: Load and Parse Interview Analyses
+
+**AI Agent Analysis Process**:
+1. **Load interview analysis files**
+   - If single file: Load specified file
+   - If multiple files: Load all specified files
+   - If "recent": Load all `*-interview-analysis.md` files from last 30 days
+
+2. **Extract customer data for each interview**:
+   - Customer name, company, role
+   - Customer fit score (X/10)
+   - Urgency level (High/Medium/Low)
+   - Willingness to pay (High/Medium/Low)
+   
+3. **Extract actionable items from each interview**:
+   - Pain points with customer quotes
+   - Feature requests (explicit asks)
+   - Success criteria (becomes acceptance criteria)
+   - Failure criteria (becomes constraints)
+   - Integration requirements
+   - Follow-up questions that need product answers
+
+4. **Create insight inventory**:
+   ```
+   [
+     {
+       customer: "Ronil Dhruva",
+       company: "Microsoft",
+       fit_score: 9,
+       urgency: "High",
+       willingness_to_pay: "High",
+       insights: [
+         {
+           type: "feature_request",
+           quote: "VP invite => meet - unsaid rules",
+           pain_point: "Hierarchy-aware meeting prioritization",
+           category: "calendar_management"
+         },
+         ...
+       ]
+     },
+     ...
+   ]
+   ```
+
+### Step 2: Pattern Recognition & Consolidation
+
+**AI Agent Pattern Process**:
+1. **Group similar insights across customers**
+   - Cluster by semantic similarity (not just keyword matching)
+   - Identify common themes (e.g., "hierarchy rules", "email triage", "meeting context")
+   - Note variations in requirements across customers
+   
+2. **Create consolidated insight groups**:
+   ```
+   Insight Group: "Hierarchy-aware scheduling"
+   Customers: Ronil Dhruva (Microsoft), Sanjoy Ghosh (Microsoft)
+   Quotes:
+     - Ronil: "VP invite => meet - unsaid rules"
+     - Sanjoy: "If PM2 will decline, if Partner then will talk"
+   Common Need: System that understands organizational hierarchy for meeting prioritization
+   Variations: Microsoft-specific rules, may vary by company
+   ```
+
+3. **Rank insight groups by impact**:
+   - Number of customers requesting (primary factor)
+   - Average customer fit score
+   - Average urgency level
+   - Average willingness to pay
+
+### Step 3: Search Existing Issues & Codebase
+
+**AI Agent Search Process**:
+1. **For each insight group, search issues**:
+   - Use {{search_issues}} to find semantic matches in titles and bodies
+   - Check for related/duplicate issues
+   - Find parent epic issues
+   - Note existing priority and status
+   
+2. **Search codebase for existing solutions**:
+   - Search for related functionality already implemented
+   - Find relevant code areas (helps with scoping)
+   - Identify potential technical blockers
+   
+3. **Classify each insight group**:
+   - **New Issue**: No similar issue exists
+   - **Update Existing**: Similar issue exists, add customer context
+   - **Already Built**: Feature exists in codebase, notify for customer demo
+   - **Needs Research**: Too vague, create discovery issue
+
+### Step 4: Calculate Priority Scores
+
+**AI Agent Priority Calculation**:
+
+**Formula** (flexible based on available data):
+```
+Priority Score = (Number of Customers × 0.4) +
+                (Avg Customer Fit Score / 10 × 0.3) +
+                (Urgency Factor × 0.2) +
+                (Willingness to Pay Factor × 0.1)
+
+Where:
+- Number of Customers: Actual count (normalized to 0-10 scale if >10)
+- Customer Fit Score: Average across requesting customers (already 0-10)
+- Urgency Factor: High=10, Medium=5, Low=2 (average if multiple)
+- Willingness to Pay: High=10, Medium=5, Low=2 (average if multiple)
+```
+
+**Priority Labels**:
+- `priority:critical` - Score 8.5-10 (Multiple high-fit customers with urgent needs)
+- `priority:high` - Score 6.5-8.4 (Multiple customers or high-fit customer with urgent need)
+- `priority:medium` - Score 4.5-6.4 (Single customer or multiple with lower urgency)
+- `priority:low` - Score 0-4.4 (Single low-fit customer or low urgency)
+
+**Handling Missing Data**:
+- If customer fit score missing: Use 5/10 (neutral)
+- If urgency missing: Use "Medium"
+- If willingness to pay missing: Omit from calculation, redistribute weights
+- If only one customer: Still calculate based on their metrics
+
+### Step 5: Generate Issue Proposals
+
+**AI Agent Issue Generation**:
+
+For each insight group, create issue proposal:
+
+**For New Issues**:
+```markdown
+Title: [Brief, actionable title from customer quote or pain point]
+
+## Customer Context
+**Requested by**: 
+- [Customer 1 Name] ([Company], [Role]) - Fit Score: [X/10] - [Link to analysis]
+- [Customer 2 Name] ([Company], [Role]) - Fit Score: [X/10] - [Link to analysis]
+
+**Priority Calculation**:
+- Number of Customers: [N]
+- Avg Customer Fit Score: [X.X/10]
+- Urgency: [High/Medium/Low]
+- Willingness to Pay: [High/Medium/Low]
+- **Final Priority Score: [X.X/10]**
+
+## Customer Quotes
+> "[Quote from Customer 1]"
+> — Customer 1 Name, Company
+
+> "[Quote from Customer 2]"  
+> — Customer 2 Name, Company
+
+## Problem Statement
+[Clear description of the pain point or need, synthesized across customers]
+
+## Success Criteria (from customers)
+- [Criterion 1 from interviews]
+- [Criterion 2 from interviews]
+- [Criterion 3 from interviews]
+
+## Constraints/Failure Criteria
+- [Constraint 1 - e.g., "Don't be rude in responses" - Ronil]
+- [Constraint 2 - e.g., "Don't mix work and personal" - Sanjoy]
+
+## Proposed Solution (if suggested by customers)
+[If customer suggested a solution or if obvious from context]
+
+## Related Issues
+- #[issue number] - [Description and how it relates]
+
+## Customer Analysis Links
+- [Customer 1]: `docs/customer-development/[customer1]-interview-analysis.md`
+- [Customer 2]: `docs/customer-development/[customer2]-interview-analysis.md`
+
+## Labels
+- `user-reported` - Sourced from customer interviews/feedback
+- `priority:[level]` - Auto-assigned based on score
+- `segment:[segment-name]` - Market segment (e.g., microsoft, consulting, executive)
+
+## Notes
+[Any additional context, variations in requirements, or implementation considerations]
+```
+
+**For Existing Issue Updates**:
+```markdown
+## Comment to Add to Issue #[number]
+
+### Additional Customer Request
+**Customer**: [Name] ([Company], [Role]) - Fit Score: [X/10]  
+**Interview Analysis**: [Link to interview-analysis.md]  
+**Date**: [Analysis Date]
+
+**Customer Quote**:
+> "[Direct quote from interview]"
+
+**Success Criteria from Customer**:
+- [Criterion 1]
+- [Criterion 2]
+
+**Additional Context**:
+[Any new insights, variations in requirements, or constraints from this customer]
+
+---
+**Priority Update Recommendation**: 
+Current Priority: [Current Label]
+Recommended Priority: [New Label] (Now [N] customers requesting)
+```
+
+**For Already Built Features**:
+```markdown
+## Already Addressed: [Pain Point/Feature]
+
+**Customer(s)**: [Name(s)]  
+**Existing Solution**: [Description of what we already built]  
+**Code Location**: [File paths or feature area]  
+**Recommendation**: 
+- Add to customer demo/onboarding
+- Update documentation
+- Follow up with customer to show existing solution
+
+**Note for Follow-up Email**:
+"[Customer], regarding your need for [X], we actually have [existing feature] that addresses this. Let me show you how it works..."
+```
+
+### Step 6: Present Triage Summary to PM
+
+**AI Agent Summary Generation**:
+
+Create comprehensive triage summary:
+
+```markdown
+# Customer Insight Triage Summary
+**Date**: [Today's Date]
+**Customers Analyzed**: [N] customers
+**Analysis Period**: [Date range or "Single customer"]
+
+## Executive Summary
+- **Total Insights Extracted**: [N]
+- **New Issues to Create**: [N]
+- **Existing Issues to Update**: [N]
+- **Features Already Built**: [N]
+- **Total Customers Covered**: [Names]
+
+## Priority Distribution
+- Critical: [N] issues
+- High: [N] issues  
+- Medium: [N] issues
+- Low: [N] issues
+
+---
+
+## SECTION 1: NEW ISSUES TO CREATE
+
+### Priority: Critical ([N] issues)
+
+#### 1. [Issue Title]
+**Type**: Feature Request | Enhancement | Bug | Integration  
+**Customers**: [Name 1] (Microsoft), [Name 2] (Deloitte) - [N] total  
+**Priority Score**: [X.X/10]  
+**Quote**: "[Most compelling customer quote]"
+
+**Why Critical**:
+- [N] high-fit customers requesting
+- High urgency and willingness to pay
+- Blocking customer adoption
+
+**Similar Issues**: #123, #456 (will be linked)  
+**Labels**: `priority:critical`, `user-reported`, `segment:microsoft`
+
+**Issue Details**: [Expand to show full issue body]
+
+---
+
+#### 2. [Next Critical Issue]
+...
+
+### Priority: High ([N] issues)
+
+[Same format as Critical]
+
+### Priority: Medium ([N] issues)
+
+[Same format]
+
+### Priority: Low ([N] issues)
+
+[Same format]
+
+---
+
+## SECTION 2: EXISTING ISSUES TO UPDATE
+
+### 1. Issue #123: [Existing Issue Title]
+**Current Priority**: `priority:medium`  
+**Recommended Priority**: `priority:high` ⬆️  
+**Reason**: Adding [N] more customer(s), now [total] customers requesting
+
+**New Customer(s)**: 
+- [Customer Name] ([Company], Fit: [X/10])
+
+**Quote to Add**: 
+> "[Customer quote]"
+
+**Comment Preview**: [Expand to show full comment]
+
+---
+
+### 2. Issue #456: [Another Existing Issue]
+...
+
+---
+
+## SECTION 3: FEATURES ALREADY BUILT
+
+### 1. [Feature/Pain Point]
+**Customer(s)**: [Name(s)]  
+**Existing Solution**: [What we built]  
+**Recommendation**: Add to customer demo, update docs
+
+**Follow-up Note**: 
+> "Regarding your need for [X], we have [existing feature]. Let me show you..."
+
+---
+
+## SECTION 4: NEEDS DISCOVERY
+
+### 1. [Vague Pain Point]
+**Customer**: [Name]  
+**Issue**: Too vague to implement directly  
+**Recommendation**: Create research issue with `needs:discovery` label  
+**Next Steps**: Schedule follow-up with customer for deeper dive
+
+---
+
+## CONSOLIDATED PATTERNS
+
+### Cross-Customer Themes
+1. **Hierarchy-Aware Scheduling** - [N] customers (Microsoft segment)
+2. **Email Triage Automation** - [N] customers (Microsoft, Consulting segments)
+3. **AI Trust & Delegation Boundaries** - [N] customers (All segments)
+
+### Segment-Specific Needs
+- **Microsoft Segment**: Hierarchy rules, Office 365 integration, compliance
+- **Consulting Segment**: Multi-stakeholder coordination, client hierarchy awareness
+
+---
+
+## RECOMMENDED ACTIONS
+
+1. ✅ **Create Critical Issues First** ([N] issues)
+2. ✅ **Update High-Priority Existing Issues** ([N] issues)
+3. ✅ **Schedule Demo for Built Features** ([N] customers)
+4. ⚠️ **Schedule Discovery Calls** ([N] vague issues)
+
+## DEDUPLICATION DECISIONS
+
+The following similar insights were consolidated:
+
+1. **Merged Into Issue**: "Hierarchy-aware scheduling"
+   - Ronil's "VP invite => meet" 
+   - Sanjoy's "If PM2 will decline, if Partner then will talk"
+   - **Rationale**: Same core need, different expressions
+
+2. **Kept Separate**: 
+   - Issue: "Email auto-response" vs "Email triage"
+   - **Rationale**: Different use cases - one is responding, other is prioritizing
+
+**Review Deduplication?** If any merges seem wrong, let me know before I create issues.
+
+---
+
+## APPROVAL REQUIRED
+
+Please review and choose action:
+- **"Approve all"** - Create all [N] new issues and update [N] existing issues
+- **"Approve critical only"** - Only create/update critical priority items
+- **"Approve high and critical"** - Create/update critical and high priority items
+- **"Show me issue #X"** - View full details for specific issue before approval
+- **"Skip issue Y"** - Exclude specific issue from creation
+- **"Merge issues X and Y"** - Consolidate further before creating
+- **"Change priority of issue X to [level]"** - Override priority calculation
+
+```
+
+### Step 7: User Approval & Execution
+
+**AI Agent Interaction Process**:
+
+1. **Wait for PM approval**:
+   - Show triage summary
+   - Wait for command
+   - Handle refinements/questions
+
+2. **Process approval commands**:
+   - "Approve all" → Mark all for creation
+   - "Approve critical only" → Filter to critical
+   - "Show me issue #X" → Display full issue proposal
+   - "Skip issue Y" → Remove from creation list
+   - "Merge issues X and Y" → Re-consolidate and regenerate
+
+3. **Execute approved actions**:
+   
+   **For New Issues**:
+   ```bash
+   gh issue create \
+     --title "[Title]" \
+     --body "[Full issue body from proposal]" \
+     --label "user-reported,priority:[level],segment:[segment]"
+   ```
+   
+   **For Existing Issue Updates**:
+   ```bash
+   gh issue comment [issue-number] \
+     --body "[Comment from proposal]"
+   
+   gh issue edit [issue-number] \
+     --add-label "priority:[new-level]"
+   ```
+   
+4. **Track execution results**:
+   - Log created issue numbers
+   - Log updated issue numbers
+   - Handle any errors
+   - Prepare final report
+
+### Step 8: Create Triage Documentation
+
+**AI Agent Documentation Process**:
+
+1. **Create triage log file**: `docs/customer-development/triage/[YYYY-MM-DD]-triage-log.md`
+
+**Triage Log Template**:
+```markdown
+# Customer Insight Triage - [Date]
+
+## Summary
+**Customers Analyzed**: [N] customers  
+**Analysis Files**: 
+- [customer1]-interview-analysis.md
+- [customer2]-interview-analysis.md
+
+**Execution Results**:
+- ✅ Created [N] new issues
+- ✅ Updated [N] existing issues  
+- ℹ️ Identified [N] already-built features
+- ⚠️ Flagged [N] items for discovery
+
+---
+
+## Customer → Issue Mapping
+
+### Customer: [Customer 1 Name] ([Company])
+**Analysis**: docs/customer-development/[customer1]-interview-analysis.md  
+**Fit Score**: [X/10]  
+**Issues Filed**:
+- #[new-issue-1] - [Title] (NEW - Priority: Critical)
+- #[existing-issue-1] - [Title] (UPDATED - Added customer context)
+- Built: [Feature] (NO ISSUE - Already exists)
+
+**Key Insights**:
+1. Pain Point: [X] → Issue #[number]
+2. Pain Point: [Y] → Issue #[number]  
+3. Feature Request: [Z] → Already built
+
+---
+
+### Customer: [Customer 2 Name] ([Company])
+[Same format]
+
+---
+
+## Issue → Customer Mapping
+
+### Issue #[number]: [Title]
+**Priority**: Critical  
+**Status**: New issue created  
+**Customers Requesting**: [N]
+- [Customer 1] ([Company], Fit: [X/10])
+- [Customer 2] ([Company], Fit: [X/10])
+
+**Customer Quotes**:
+> "[Quote 1]" — Customer 1
+
+> "[Quote 2]" — Customer 2
+
+---
+
+## Pattern Analysis
+
+### Cross-Customer Themes
+1. **Hierarchy-Aware Scheduling**
+   - Customers: Ronil (Microsoft), Sanjoy (Microsoft)
+   - Issues: #[number], #[number]
+   - Priority: Critical
+   - Segment: Microsoft employees
+
+2. **Email Triage Automation**  
+   - Customers: Sanjoy (Microsoft), [Others]
+   - Issues: #[number]
+   - Priority: High
+   - Segment: Multiple
+
+### Segment-Specific Patterns
+**Microsoft Segment**:
+- Hierarchy rules enforcement
+- Office 365 integration critical
+- Compliance requirements
+
+**Consulting Segment**:
+- Multi-stakeholder coordination
+- Client hierarchy awareness
+- Travel scheduling complexity
+
+---
+
+## Follow-up Actions Required
+
+### Customer Follow-ups
+- [ ] **Demo existing features** to [Customer 1], [Customer 2]
+  - Feature: [X] addresses their need for [Y]
+  - Schedule by: [Date]
+
+- [ ] **Schedule discovery call** with [Customer 3]
+  - Topic: [Vague pain point] needs clarification
+  - Schedule by: [Date]
+
+### Product Follow-ups
+- [ ] **Prioritize Issue #[number]** for next sprint
+  - Critical priority, [N] customers
+  
+- [ ] **Research Issue #[number]**
+  - Needs technical feasibility assessment
+
+---
+
+## Metrics
+
+**Triage Efficiency**:
+- Insights extracted: [N]
+- Issues created: [N]
+- Issues updated: [N]
+- Deduplication rate: [X%]
+- Time saved: ~[X] hours vs manual triage
+
+**Customer Coverage**:
+- Total customers: [N]
+- High-fit customers (8+): [N]
+- Issues per customer: [X average]
+- Customers with built features: [N]
+
+**Priority Distribution**:
+- Critical: [N] ([X%])
+- High: [N] ([X%])
+- Medium: [N] ([X%])
+- Low: [N] ([X%])
+
+---
+
+## Next Triage Session
+
+**Recommended Timing**: [Date - 1 week after N customer interviews]  
+**Candidates for Next Triage**:
+- [Upcoming interview 1]
+- [Upcoming interview 2]
+
+**Backlog**:
+- [ ] [Customer] analysis pending
+- [ ] [Customer] analysis pending
+
+```
+
+2. **Update interview analysis files**:
+   - Add section at end of each analysis file
+   - Link to created/updated issues
+   - Link to triage log
+
+**Addition to Interview Analysis Files**:
+```markdown
+---
+
+## Issues Filed from This Interview
+
+**Triage Date**: [Date]  
+**Triage Log**: [Link to triage log file]
+
+### New Issues Created
+- Issue #[number]: [Title] - Priority: [Level]
+- Issue #[number]: [Title] - Priority: [Level]
+
+### Existing Issues Updated
+- Issue #[number]: [Title] - Added customer context
+
+### Features Already Built (For Demo)
+- [Feature name]: [Brief description]
+
+### Next Actions
+- [ ] Demo existing features
+- [ ] Follow up on Issue #[number] implementation
+- [ ] Discovery call for [vague topic]
+```
+
+### Step 9: Final Report to PM
+
+**AI Agent Final Report**:
+
+```markdown
+# ✅ Customer Insight Triage Complete
+
+## Execution Summary
+**Date**: [Date]  
+**Customers Processed**: [N]  
+**Duration**: [X minutes]
+
+## Results
+✅ **Created [N] new GitHub issues**
+- Critical: [N] issues (#[numbers])
+- High: [N] issues (#[numbers])
+- Medium: [N] issues (#[numbers])
+- Low: [N] issues (#[numbers])
+
+✅ **Updated [N] existing GitHub issues**
+- Issues: #[numbers]
+- All updated with customer context and quotes
+
+ℹ️ **Identified [N] already-built features**
+- Recommend demo to customers: [Names]
+
+⚠️ **Flagged [N] items for discovery**
+- Need follow-up calls with: [Customer names]
+
+## Documentation Created
+📄 **Triage Log**: `docs/customer-development/triage/[date]-triage-log.md`
+📄 **Updated Analysis Files**: [N] files updated with issue links
+
+## Top Priority Issues
+1. **Issue #[number]**: [Title] (Critical - [N] customers)
+2. **Issue #[number]**: [Title] (Critical - [N] customers)
+3. **Issue #[number]**: [Title] (High - [N] customers)
+
+## Recommended Next Steps
+1. 🎯 **Prioritize** Issue #[number] for immediate implementation
+2. 📧 **Email customers** about already-built features for demo
+3. 📞 **Schedule discovery calls** for [vague topics]
+4. 📊 **Review** triage log for cross-customer patterns
+5. 🗓️ **Schedule next triage** after [N] more interviews
+
+## Customer Follow-ups Required
+- **[Customer 1]**: Demo [feature], discuss Issue #[number]
+- **[Customer 2]**: Discovery call for [topic]
+- **[Customer 3]**: Show existing solution for [pain point]
+
+---
+**View Full Triage Log**: `docs/customer-development/triage/[date]-triage-log.md`
+```
+
+## OUTPUT FILES
+
+### Created Files
+1. **`docs/customer-development/triage/[YYYY-MM-DD]-triage-log.md`**
+   - Complete triage session documentation
+   - Customer → Issue mapping
+   - Issue → Customer mapping
+   - Pattern analysis
+   - Metrics and follow-ups
+
+### Updated Files
+2. **Interview analysis files** (e.g., `ronil-dhruva-interview-analysis.md`)
+   - Add "Issues Filed from This Interview" section
+   - Link to created/updated issues
+   - Link to triage log
+
+3. **GitHub Issues**
+   - New issues created with full customer context
+   - Existing issues updated with customer comments
+   - All labeled appropriately
+
+### GitHub Labels Used
+- `user-reported` - All customer-sourced issues (use existing label, not customer-request)
+- `priority:critical` - Score 8.5-10
+- `priority:high` - Score 6.5-8.4
+- `priority:medium` - Score 4.5-6.4
+- `priority:low` - Score 0-4.4
+- `segment:microsoft` - Market segment tags
+- `segment:consulting` - Market segment tags
+- `segment:executive` - Executive user segment
+- `needs:discovery` - Requires more research
+
+**Note**: Do NOT use granular feature-type tags (calendar, email, ai-delegation, etc.) or bug-specific tags. Keep labels minimal - use user-reported for customer issues and segment tags for market segmentation.
+
+## EXAMPLES
+
+### Example 1: Single Customer Triage
+
+```
+PM: "Triage the interview analysis for Ronil Dhruva"
+
+AI Agent Process:
+1. Reads docs/customer-development/ronil-dhruva-interview-analysis.md
+2. Extracts 5 pain points and 3 feature requests
+3. Searches GitHub issues - finds 1 similar, 7 new
+4. Calculates priorities (Ronil fit: 9/10, urgency: High)
+5. Presents triage summary showing:
+   - 7 new issues to create (2 critical, 3 high, 2 medium)
+   - 1 existing issue to update (#200 - email management)
+   - 1 already-built feature (time parsing)
+
+PM: "Approve critical and high only"
+
+AI Agent:
+1. Creates 5 issues (#494-#498)
+2. Updates issue #200 with Ronil's quote
+3. Creates triage log: docs/customer-development/triage/2025-01-15-triage-log.md
+4. Updates ronil-dhruva-interview-analysis.md with issue links
+5. Shows final report with all issue numbers
+```
+
+### Example 2: Multi-Customer Pattern Recognition
+
+```
+PM: "Triage all recent interviews"
+
+AI Agent Process:
+1. Finds 3 analysis files: ronil-dhruva, sanjoy-ghosh, samarth-mathur
+2. Extracts insights from all 3
+3. Identifies pattern: All 3 mentioned hierarchy-aware scheduling
+   - Ronil: "VP invite => meet"
+   - Sanjoy: "If PM2 will decline, if Partner then will talk"
+   - Samarth: [Similar M&A hierarchy challenges]
+4. Consolidates into single high-priority issue
+5. Presents triage summary:
+   - 1 critical issue: "Hierarchy-aware meeting prioritization" (3 customers)
+   - Priority score: 9.5/10 (3 customers × 0.4 + 9 avg fit × 0.3 + ...)
+   - 8 other issues (some from single customers, lower priority)
+
+PM: "Approve all"
+
+AI Agent:
+1. Creates issue #494: "Hierarchy-aware meeting prioritization"
+   - Comments include quotes from all 3 customers
+   - Labels: priority:critical, user-reported, segment:microsoft
+2. Creates 8 other issues (#495-#502)
+3. Creates comprehensive triage log showing patterns
+4. Updates all 3 interview analysis files
+5. Shows final report highlighting the pattern discovery
+```
+
+### Example 3: Existing Issue Enhancement
+
+```
+PM: "Triage sanjoy-ghosh-interview-analysis.md"
+
+AI Agent Process:
+1. Reads analysis
+2. Extracts email triage pain point with quote:
+   "People pinging repeatedly when answer is No"
+3. Searches GitHub issues
+4. Finds issue #200: "Email management and auto-response" (currently priority:medium)
+5. Presents triage summary:
+   - Update issue #200 (now 2 customers: Ronil + Sanjoy)
+   - Recommend priority change: medium → high
+   - Show comment to add with Sanjoy's quote
+
+PM: "Approve"
+
+AI Agent:
+1. Adds comment to issue #200 with Sanjoy's context
+2. Updates label: priority:medium → priority:high
+3. Creates triage log documenting the update
+4. Updates sanjoy-ghosh-interview-analysis.md
+5. Shows final report
+```
+
+### Example 4: Already-Built Feature
+
+```
+PM: "Triage ronil-dhruva-interview-analysis.md"
+
+AI Agent Process:
+1. Reads analysis
+2. Finds pain point: "Better time parsing from natural language"
+3. Searches codebase, finds existing TimeParser class in src/utils/
+4. Presents triage summary:
+   - No issue to create (feature exists)
+   - Recommend: Add to Ronil's demo
+   - Follow-up note: "We have intelligent time parsing that handles..."
+
+PM: "Approve"
+
+AI Agent:
+1. Creates triage log with "Already Built" section
+2. Updates ronil-dhruva-interview-analysis.md with note about existing feature
+3. Shows final report with demo recommendation
+```
+
+## SUCCESS METRICS
+
+- **Traceability**: 100% of customer-sourced issues have customer context in comments
+- **Deduplication**: <15% duplicate issue creation rate (consolidated during triage)
+- **Customer Coverage**: All analyzed customers get insights triaged
+- **Time Savings**: PM saves 2-4 hours per customer interview analysis
+- **Prioritization Accuracy**: Issues with multiple customers get higher priority
+- **Pattern Discovery**: Cross-customer themes identified in multi-customer triage
+
+## EDGE CASES
+
+### 1. Customer Requests Already-Built Feature
+**Action**: 
+- Don't create issue
+- Add to "Features Already Built" section in triage summary
+- Create note in triage log for customer demo
+- Update customer's analysis file with demo recommendation
+
+### 2. Vague Pain Point Without Clear Solution
+**Action**:
+- Create research issue with `needs:discovery` label
+- Include customer quote and context
+- Flag for PM to schedule follow-up discovery call
+- Note in triage log under "Needs Discovery"
+
+### 3. Conflicting Requests from Different Customers
+**Action**:
+- Create issue noting the conflict in problem statement
+- Add both customer contexts in comments
+- Tag both customers' analyses
+- Add note: "Customer requirements vary - needs product decision"
+- Flag for PM review
+
+### 4. Customer Requests Infeasible Feature
+**Action**:
+- Create issue with `needs:evaluation` label
+- Document customer need and why it seems infeasible
+- Include customer quote for context
+- Flag for PM technical review
+- Don't commit to customer yet
+
+### 5. Same Customer in Multiple Analysis Files
+**Action**:
+- Warn PM about duplicate customer
+- Ask which analysis file to use
+- Or: Consolidate insights from both files
+- Track in triage log
+
+### 6. No Interview Analysis File Available
+**Action**:
+- Check if raw interview notes provided
+- If yes: Trigger insight-analysis workflow first
+- If no: Error message "Please provide interview analysis or raw notes"
+- Don't proceed without structured analysis
+
+### 7. Missing Priority Data (Fit Score, Urgency, etc.)
+**Action**:
+- Use defaults: fit=5/10, urgency=Medium
+- Note in triage log which data was missing
+- Calculate priority with available data
+- Flag for PM to update analysis file
+
+### 8. GitHub API Rate Limits
+**Action**:
+- Batch issue creation (don't create one-by-one)
+- Show progress: "Creating issue 3 of 15..."
+- If rate limited: Pause and resume
+- Log any failures for manual creation
+
+## RELATED WORKFLOWS
+
+**Prerequisite Workflows**:
+- `insight-analysis.md` - Must run before triage if only raw notes available
+- `interview-preparation.md` - Earlier in the customer development cycle
+
+**Downstream Workflows**:
+- `spec.md` - Issues created here feed into spec workflow
+- `design.md` - High-priority customer issues drive design work
+- `implement.md` - Customer-validated issues are implemented
+
+**Parallel Workflows**:
+- `strategic-brainstorming.md` - Patterns discovered here inform strategy
+
+## NOTES FOR PM
+
+**Best Practices**:
+1. **Run triage in batches**: Process 3-5 customer interviews at once to discover patterns
+2. **Regular cadence**: Triage every week or after N interviews (whichever comes first)
+3. **Review deduplication**: Always review consolidated issues before approving
+4. **Follow up quickly**: Demo already-built features to customers within 48 hours
+5. **Track metrics**: Use triage logs to track customer request patterns over time
+
+**Common PM Actions**:
+- Override priority for strategic reasons: "Change priority of issue X to critical"
+- Merge issues further: "Merge issues #494 and #495"
+- Skip low-value issues: "Skip all low priority issues"
+- Request more detail: "Show me issue #494 full details"
+
+**Triage Log Benefits**:
+- Track which customers asked for which features
+- Show customer evidence during prioritization discussions
+- Reference customer quotes during design/spec work
+- Follow up with customers when features ship
+
+---
+
+**Document Created**: January 2025  
+**Version**: 1.0  
+**Status**: Ready for use