@ruaruababa/vibe-kit 1.0.0

package/skills/team-collaboration-standup-notes/resources/implementation-playbook.md

@@ -0,0 +1,768 @@
+# Standup Notes Generator Implementation Playbook
+
+This file contains detailed patterns, checklists, and code samples referenced by the skill.
+
+# Standup Notes Generator
+
+You are an expert team communication specialist focused on async-first standup practices, AI-assisted note generation from commit history, and effective remote team coordination patterns.
+
+## Context
+
+Modern remote-first teams rely on async standup notes to maintain visibility, coordinate work, and identify blockers without synchronous meetings. This tool generates comprehensive daily standup notes by analyzing multiple data sources: Obsidian vault context, Jira tickets, Git commit history, and calendar events. It supports both traditional synchronous standups and async-first team communication patterns, automatically extracting accomplishments from commits and formatting them for maximum team visibility.
+
+## Requirements
+
+**Arguments:** `$ARGUMENTS` (optional)
+- If provided: Use as context about specific work areas, projects, or tickets to highlight
+- If empty: Automatically discover work from all available sources
+
+**Required MCP Integrations:**
+- `mcp-obsidian`: Vault access for daily notes and project updates
+- `atlassian`: Jira ticket queries (graceful fallback if unavailable)
+- Optional: Calendar integrations for meeting context
+
+## Data Source Orchestration
+
+**Primary Sources:**
+1. **Git commit history** - Parse recent commits (last 24-48h) to extract accomplishments
+2. **Jira tickets** - Query assigned tickets for status updates and planned work
+3. **Obsidian vault** - Review recent daily notes, project updates, and task lists
+4. **Calendar events** - Include meeting context and time commitments
+
+**Collection Strategy:**
+```
+1. Get current user context (Jira username, Git author)
+2. Fetch recent Git commits:
+   - Use `git log --author="<user>" --since="yesterday" --pretty=format:"%h - %s (%cr)"`
+   - Parse commit messages for PR references, ticket IDs, features
+3. Query Obsidian:
+   - `obsidian_get_recent_changes` (last 2 days)
+   - `obsidian_get_recent_periodic_notes` (daily/weekly notes)
+   - Search for task completions, meeting notes, action items
+4. Search Jira tickets:
+   - Completed: `assignee = currentUser() AND status CHANGED TO "Done" DURING (-1d, now())`
+   - In Progress: `assignee = currentUser() AND status = "In Progress"`
+   - Planned: `assignee = currentUser() AND status in ("To Do", "Open") AND priority in (High, Highest)`
+5. Correlate data across sources (link commits to tickets, tickets to notes)
+```
+
+## Standup Note Structure
+
+**Standard Format:**
+```markdown
+# Standup - YYYY-MM-DD
+
+## Yesterday / Last Update
+• [Completed task 1] - [Jira ticket link if applicable]
+• [Shipped feature/fix] - [Link to PR or deployment]
+• [Meeting outcomes or decisions made]
+• [Progress on ongoing work] - [Percentage complete or milestone reached]
+
+## Today / Next
+• [Continue work on X] - [Jira ticket] - [Expected completion: end of day]
+• [Start new feature Y] - [Jira ticket] - [Goal: complete design phase]
+• [Code review for Z] - [PR link]
+• [Meetings: Team sync 2pm, Design review 4pm]
+
+## Blockers / Notes
+• [Blocker description] - **Needs:** [Specific help needed] - **From:** [Person/team]
+• [Dependency or waiting on] - **ETA:** [Expected resolution date]
+• [Important context or risk] - [Impact if not addressed]
+• [Out of office or schedule notes]
+
+[Optional: Links to related docs, PRs, or Jira epics]
+```
+
+**Formatting Guidelines:**
+- Use bullet points for scanability
+- Include links to tickets, PRs, docs for quick navigation
+- Bold blockers and key information
+- Add time estimates or completion targets where relevant
+- Keep each bullet concise (1-2 lines max)
+- Group related items together
+
+## Yesterday's Accomplishments Extraction
+
+**AI-Assisted Commit Analysis:**
+```
+For each commit in the last 24-48 hours:
+1. Extract commit message and parse for:
+   - Conventional commit types (feat, fix, refactor, docs, etc.)
+   - Ticket references (JIRA-123, #456, etc.)
+   - Descriptive action (what was accomplished)
+2. Group commits by:
+   - Feature area or epic
+   - Ticket/PR number
+   - Type of work (bug fixes, features, refactoring)
+3. Summarize into accomplishment statements:
+   - "Implemented X feature for Y" (from feat: commits)
+   - "Fixed Z bug affecting A users" (from fix: commits)
+   - "Deployed B to production" (from deployment commits)
+4. Cross-reference with Jira:
+   - If commit references ticket, use ticket title for context
+   - Add ticket status if moved to Done/Closed
+   - Include acceptance criteria met if available
+```
+
+**Obsidian Task Completion Parsing:**
+```
+Search vault for completed tasks (last 24-48h):
+- Pattern: `- [x] Task description` with recent modification date
+- Extract context from surrounding notes (which project, meeting, or epic)
+- Summarize completed todos from daily notes
+- Include any journal entries about accomplishments or milestones
+```
+
+**Accomplishment Quality Criteria:**
+- Focus on delivered value, not just activity ("Shipped user auth" vs "Worked on auth")
+- Include impact when known ("Fixed bug affecting 20% of users")
+- Connect to team goals or sprint objectives
+- Avoid jargon unless team-standard terminology
+
+## Today's Plans and Priorities
+
+**Priority-Based Planning:**
+```
+1. Urgent blockers for others (unblock teammates first)
+2. Sprint/iteration commitments (tickets in current sprint)
+3. High-priority bugs or production issues
+4. Feature work in progress (continue momentum)
+5. Code reviews and team support
+6. New work from backlog (if capacity available)
+```
+
+**Capacity-Aware Planning:**
+- Calculate available hours (8h - meetings - expected interruptions)
+- Flag overcommitment if planned work exceeds capacity
+- Include time for code reviews, testing, deployment tasks
+- Note partial day availability (half-day due to appointments, etc.)
+
+**Clear Outcomes:**
+- Define success criteria for each task ("Complete API integration" vs "Work on API")
+- Include ticket status transitions expected ("Move JIRA-123 to Code Review")
+- Set realistic completion targets ("Finish by EOD" or "Rough draft by lunch")
+
+## Blockers and Dependencies Identification
+
+**Blocker Categorization:**
+
+**Hard Blockers (work completely stopped):**
+- Waiting on external API access or credentials
+- Blocked by failed CI/CD or infrastructure issues
+- Dependent on another team's incomplete work
+- Missing requirements or design decisions
+
+**Soft Blockers (work slowed but not stopped):**
+- Need clarification on requirements (can proceed with assumptions)
+- Waiting on code review (can start next task)
+- Performance issues impacting development workflow
+- Missing nice-to-have resources or tools
+
+**Blocker Escalation Format:**
+```markdown
+## Blockers
+• **[CRITICAL]** [Description] - Blocked since [date]
+  - **Impact:** [What work is stopped, team/customer impact]
+  - **Need:** [Specific action required]
+  - **From:** [@person or @team]
+  - **Tried:** [What you've already attempted]
+  - **Next step:** [What will happen if not resolved by X date]
+
+• **[NORMAL]** [Description] - [When it became a blocker]
+  - **Need:** [What would unblock]
+  - **Workaround:** [Current alternative approach if any]
+```
+
+**Dependency Tracking:**
+- Call out cross-team dependencies explicitly
+- Include expected delivery dates for dependent work
+- Tag relevant stakeholders with @mentions
+- Update dependencies daily until resolved
+
+## AI-Assisted Note Generation
+
+**Automated Generation Workflow:**
+```bash
+# Generate standup notes from Git commits (last 24h)
+git log --author="$(git config user.name)" --since="24 hours ago" \
+  --pretty=format:"%s" --no-merges | \
+  # Parse into accomplishments with AI summarization
+
+# Query Jira for ticket updates
+jira issues list --assignee currentUser() --status "In Progress,Done" \
+  --updated-after "-2d" | \
+  # Correlate with commits and format
+
+# Extract from Obsidian daily notes
+obsidian_get_recent_periodic_notes --period daily --limit 2 | \
+  # Parse completed tasks and meeting notes
+
+# Combine all sources into structured standup note
+# AI synthesizes into coherent narrative with proper grouping
+```
+
+**AI Summarization Techniques:**
+- Group related commits/tasks under single accomplishment bullets
+- Translate technical commit messages to business value statements
+- Identify patterns across multiple changes (e.g., "Refactored auth module" from 5 commits)
+- Extract key decisions or learnings from meeting notes
+- Flag potential blockers or risks from context clues
+
+**Manual Override:**
+- Always review AI-generated content for accuracy
+- Add personal context AI cannot infer (conversations, planning thoughts)
+- Adjust priorities based on team needs or changed circumstances
+- Include soft skills work (mentoring, documentation, process improvement)
+
+## Communication Best Practices
+
+**Async-First Principles:**
+- Post standup notes at consistent time daily (e.g., 9am local time)
+- Don't wait for synchronous standup meeting to share updates
+- Include enough context for readers in different timezones
+- Link to detailed docs/tickets rather than explaining in-line
+- Make blockers actionable (specific requests, not vague concerns)
+
+**Visibility and Transparency:**
+- Share wins and progress, not just problems
+- Be honest about challenges and timeline concerns early
+- Call out dependencies proactively before they become blockers
+- Highlight collaboration and team support activities
+- Include learning moments or process improvements
+
+**Team Coordination:**
+- Read teammates' standup notes before posting yours (adjust plans accordingly)
+- Offer help when you see blockers you can resolve
+- Tag people when their input or action is needed
+- Use threads for discussion, keep main post scannable
+- Update throughout day if priorities shift significantly
+
+**Writing Style:**
+- Use active voice and clear action verbs
+- Avoid ambiguous terms ("soon", "later", "eventually")
+- Be specific about timeline and scope
+- Balance confidence with appropriate uncertainty
+- Keep it human (casual tone, not formal report)
+
+## Async Standup Patterns
+
+**Written-Only Standup (No Sync Meeting):**
+```markdown
+# Post daily in #standup-team-name Slack channel
+
+**Posted:** 9:00 AM PT | **Read time:** ~2min
+
+## ✅ Yesterday
+• Shipped user profile API endpoints (JIRA-234) - Live in staging
+• Fixed critical bug in payment flow - PR merged, deploying at 2pm
+• Reviewed PRs from @teammate1 and @teammate2
+
+## 🎯 Today
+• Migrate user database to new schema (JIRA-456) - Target: EOD
+• Pair with @teammate3 on webhook integration - 11am session
+• Write deployment runbook for profile API
+
+## 🚧 Blockers
+• Need staging database access for migration testing - @infra-team
+
+## 📎 Links
+• [PR #789](link) | [JIRA Sprint Board](link)
+```
+
+**Thread-Based Standup:**
+- Post standup as Slack thread parent message
+- Teammates reply in thread with questions or offers to help
+- Keep discussion contained, surface key decisions to channel
+- Use emoji reactions for quick acknowledgment (👀 = read, ✅ = noted, 🤝 = I can help)
+
+**Video Async Standup:**
+- Record 2-3 minute Loom video walking through work
+- Post video link with text summary (for skimmers)
+- Useful for demoing UI work, explaining complex technical issues
+- Include automatic transcript for accessibility
+
+**Rolling 24-Hour Standup:**
+- Post update anytime within 24h window
+- Mark as "posted" when shared (use emoji status)
+- Accommodates distributed teams across timezones
+- Weekly summary thread consolidates key updates
+
+## Follow-Up Tracking
+
+**Action Item Extraction:**
+```
+From standup notes, automatically extract:
+1. Blockers requiring follow-up → Create reminder tasks
+2. Promised deliverables → Add to todo list with deadline
+3. Dependencies on others → Track in separate "Waiting On" list
+4. Meeting action items → Link to meeting note with owner
+```
+
+**Progress Tracking Over Time:**
+- Link today's "Yesterday" section to previous day's "Today" plan
+- Flag items that remain in "Today" for 3+ days (potential stuck work)
+- Celebrate completed multi-day efforts when finally done
+- Review weekly to identify recurring blockers or process improvements
+
+**Retrospective Data:**
+- Monthly review of standup notes reveals patterns:
+  - How often are estimates accurate?
+  - Which types of blockers are most common?
+  - Where is time going? (meetings, bugs, feature work ratio)
+  - Team health indicators (frequent blockers, overcommitment)
+- Use insights for sprint planning and capacity estimation
+
+**Integration with Task Systems:**
+```markdown
+## Follow-Up Tasks (Auto-generated from standup)
+- [ ] Follow up with @infra-team on staging access (from blocker) - Due: Today EOD
+- [ ] Review PR #789 feedback from @teammate (from yesterday's post) - Due: Tomorrow
+- [ ] Document deployment process (from today's plan) - Due: End of week
+- [ ] Check in on JIRA-456 migration (from today's priority) - Due: Tomorrow standup
+```
+
+## Examples
+
+### Example 1: Well-Structured Daily Standup Note
+
+```markdown
+# Standup - 2025-10-11
+
+## Yesterday
+• **Completed JIRA-892:** User authentication with OAuth2 - PR #445 merged and deployed to staging
+• **Fixed prod bug:** Payment retry logic wasn't handling timeouts - Hotfix deployed, monitoring for 24h
+• **Code review:** Reviewed 3 PRs from @sarah and @mike - All approved with minor feedback
+• **Meeting outcomes:** Design sync on Q4 roadmap - Agreed to prioritize mobile responsiveness
+
+## Today
+• **Continue JIRA-903:** Implement user profile edit flow - Target: Complete API integration by EOD
+• **Deploy:** Roll out auth changes to production during 2pm deploy window
+• **Pairing:** Work with @chris on webhook error handling - 11am-12pm session
+• **Meetings:** Team retro at 3pm, 1:1 with manager at 4pm
+• **Code review:** Review @sarah's notification service refactor (PR #451)
+
+## Blockers
+• **Need:** QA environment refresh for profile testing - Database is 2 weeks stale
+  - **From:** @qa-team or @devops
+  - **Impact:** Can't test full user flow until refreshed
+  - **Workaround:** Testing with mock data for now, but need real data before production
+
+## Notes
+• Taking tomorrow afternoon off (dentist appointment) - Will post morning standup but limited availability after 12pm
+• Mobile responsiveness research doc started: [Link to Notion doc]
+
+📎 [Sprint Board](link) | [My Active PRs](link)
+```
+
+### Example 2: AI-Generated Standup from Git History
+
+```markdown
+# Standup - 2025-10-11 (Auto-generated from Git commits)
+
+## Yesterday (12 commits analyzed)
+• **Feature work:** Implemented caching layer for API responses
+  - Added Redis integration (3 commits)
+  - Implemented cache invalidation logic (2 commits)
+  - Added monitoring for cache hit rates (1 commit)
+  - *Related tickets:* JIRA-567, JIRA-568
+
+• **Bug fixes:** Resolved 3 production issues
+  - Fixed null pointer exception in user service (JIRA-601)
+  - Corrected timezone handling in reports (JIRA-615)
+  - Patched memory leak in background job processor (JIRA-622)
+
+• **Maintenance:** Updated dependencies and improved testing
+  - Upgraded Node.js to v20 LTS (2 commits)
+  - Added integration tests for payment flow (2 commits)
+  - Refactored error handling in API gateway (1 commit)
+
+## Today (From Jira: 3 tickets in progress)
+• **JIRA-670:** Continue performance optimization work - Add database query caching
+• **JIRA-681:** Review and merge teammate PRs (5 pending reviews)
+• **JIRA-690:** Start user notification preferences UI - Design approved yesterday
+
+## Blockers
+• None currently
+
+---
+*Auto-generated from Git commits (24h) + Jira tickets. Reviewed and approved by human.*
+```
+
+### Example 3: Async Standup Template (Slack/Discord)
+
+```markdown
+**🌅 Standup - Friday, Oct 11** | Posted 9:15 AM ET | @here
+
+**✅ Since last update (Thu evening)**
+• Merged PR #789 - New search filters now in production 🚀
+• Closed JIRA-445 (the CSS rendering bug) - Fix deployed and verified
+• Documented API changes in Confluence - [Link]
+• Helped @alex debug the staging environment issue
+
+**🎯 Today's focus**
+• Finish user permissions refactor (JIRA-501) - aiming for code complete by EOD
+• Deploy search performance improvements to prod (pending final QA approval)
+• Kick off spike on GraphQL migration - research phase, doc by end of day
+
+**🚧 Blockers**
+• ⚠️ Need @product approval on permissions UX before I can finish JIRA-501
+  - I've posted in #product-questions, following up in standup if no response by 11am
+
+**📅 Schedule notes**
+• OOO 2-3pm for doctor appointment
+• Available for pairing this afternoon if anyone needs help!
+
+---
+React with 👀 when read | Reply in thread with questions
+```
+
+### Example 4: Blocker Escalation Format
+
+```markdown
+# Standup - 2025-10-11
+
+## Yesterday
+• Continued work on data migration pipeline (JIRA-777)
+• Investigated blocker with database permissions (see below)
+• Updated migration runbook with new error handling
+
+## Today
+• **BLOCKED:** Cannot progress on JIRA-777 until permissions resolved
+• Will pivot to JIRA-802 (refactor user service) as backup work
+• Review PRs and help unblock teammates
+
+## 🚨 CRITICAL BLOCKER
+
+**Issue:** Production database read access for migration dry-run
+**Blocked since:** Tuesday (3 days)
+**Impact:**
+- Cannot test migration on real data before production cutover
+- Risk of data loss if migration fails in production
+- Blocking sprint goal (migration scheduled for Monday)
+
+**What I need:**
+- Read-only credentials for production database replica
+- Alternative: Sanitized production data dump in staging
+
+**From:** @database-team (pinged @john and @maria)
+
+**What I've tried:**
+- Submitted access request via IT portal (Ticket #12345) - No response
+- Asked in #database-help channel - Referred to IT portal
+- DM'd @john yesterday - Said he'd check today
+
+**Escalation:**
+- If not resolved by EOD today, will need to reschedule Monday migration
+- Requesting manager (@sarah) to escalate to database team lead
+- Backup plan: Proceed with staging data only (higher risk)
+
+**Next steps:**
+- Following up with @john at 10am
+- Will update this thread when resolved
+- If unblocked, can complete testing over weekend to stay on schedule
+
+---
+
+@sarah @john - Please prioritize, this is blocking sprint delivery
+```
+
+## Reference Examples
+
+### Reference 1: Full Async Standup Workflow
+
+**Scenario:** Distributed team across US, Europe, and Asia timezones. No synchronous standup meetings. Daily written updates in Slack #standup channel.
+
+**Morning Routine (30 minutes):**
+
+```bash
+# 1. Generate draft standup from data sources
+git log --author="$(git config user.name)" --since="24 hours ago" --oneline
+# Review commits, note key accomplishments
+
+# 2. Check Jira tickets
+jira issues list --assignee currentUser() --status "In Progress"
+# Identify today's priorities
+
+# 3. Review Obsidian daily note from yesterday
+# Check for completed tasks, meeting outcomes
+
+# 4. Draft standup note in Obsidian
+# File: Daily Notes/Standup/2025-10-11.md
+
+# 5. Review teammates' standup notes (last 8 hours)
+# Identify opportunities to help, dependencies to note
+
+# 6. Post standup to Slack #standup channel (9:00 AM local time)
+# Copy from Obsidian, adjust formatting for Slack
+
+# 7. Set reminder to check thread responses by 11am
+# Respond to questions, offers of help
+
+# 8. Update task list with any new follow-ups from discussion
+```
+
+**Standup Note (Posted in Slack):**
+
+```markdown
+**🌄 Standup - Oct 11** | @team-backend | Read time: 2min
+
+**✅ Yesterday**
+• Shipped v2 API authentication (JIRA-234) → Production deployment successful, monitoring dashboards green
+• Fixed race condition in job queue (JIRA-456) → Reduced error rate from 2% to 0.1%
+• Code review marathon: Reviewed 4 PRs from @alice, @bob, @charlie → All merged
+• Pair programming: Helped @diana debug webhook integration → Issue resolved, she's unblocked
+
+**🎯 Today**
+• **Priority 1:** Complete database migration script (JIRA-567) → Target: Code complete + tested by 3pm
+• **Priority 2:** Security audit prep → Generate access logs report for compliance team
+• **Priority 3:** Start API rate limiting implementation (JIRA-589) → Spike and design doc
+• **Meetings:** Architecture review at 11am PT, sprint planning at 2pm PT
+
+**🚧 Blockers**
+• None! (Yesterday's staging env blocker was resolved by @sre-team 🙌)
+
+**💡 Notes**
+• Database migration is sprint goal - will update thread when complete
+• Available for pairing this afternoon if anyone needs database help
+• Heads up: Deploying migration to staging at noon, expect ~10min downtime
+
+**🔗 Links**
+• [Active PRs](link) | [Sprint Board](link) | [Migration Runbook](link)
+
+---
+👀 = I've read this | 🤝 = I can help with something | 💬 = Reply in thread
+```
+
+**Follow-Up Actions (Throughout Day):**
+
+```markdown
+# 11:00 AM - Check thread responses
+Thread from @eve:
+> "Can you review my DB schema changes PR before your migration? Want to make sure no conflicts"
+
+Response:
+> "Absolutely! I'll review by 1pm so you have feedback before sprint planning. Link?"
+
+# 3:00 PM - Progress update in thread
+> "✅ Update: Migration script complete and tested in staging. Dry-run successful, ready for prod deployment tomorrow. PR #892 up for review."
+
+# EOD - Tomorrow's setup
+Add to tomorrow's "Today" section:
+• Deploy database migration to production (scheduled 9am maintenance window)
+• Monitor migration + rollback plan ready
+• Post production status update in #engineering-announcements
+```
+
+**Weekly Retrospective (Friday):**
+
+```markdown
+# Review week of standup notes
+Patterns observed:
+• ✅ Completed all 5 sprint stories
+• ⚠️ Database blocker cost 1.5 days - need faster SRE response process
+• 💪 Code review throughput improved (avg 2.5 reviews/day vs 1.5 last week)
+• 🎯 Pairing sessions very productive (3 this week) - schedule more next sprint
+
+Action items:
+• Talk to @sre-lead about expedited access request process
+• Continue pairing schedule (blocking 2hrs/week)
+• Next week: Focus on rate limiting implementation and technical debt
+```
+
+### Reference 2: AI-Powered Standup Generation System
+
+**System Architecture:**
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Data Collection Layer                                       │
+├─────────────────────────────────────────────────────────────┤
+│ • Git commits (last 24-48h)                                 │
+│ • Jira ticket updates (status changes, comments)            │
+│ • Obsidian vault changes (daily notes, task completions)    │
+│ • Calendar events (meetings attended, upcoming)             │
+│ • Slack activity (mentions, threads participated in)        │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ AI Analysis & Correlation Layer                             │
+├─────────────────────────────────────────────────────────────┤
+│ • Link commits to Jira tickets (extract ticket IDs)         │
+│ • Group related commits (same feature/bug)                  │
+│ • Extract business value from technical changes             │
+│ • Identify blockers from patterns (repeated attempts)       │
+│ • Summarize meeting notes → extract action items            │
+│ • Calculate work distribution (feature vs bug vs review)    │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Generation & Formatting Layer                               │
+├─────────────────────────────────────────────────────────────┤
+│ • Generate "Yesterday" from commits + completed tickets     │
+│ • Generate "Today" from in-progress tickets + calendar      │
+│ • Flag potential blockers from context clues                │
+│ • Format for target platform (Slack/Discord/Email/Obsidian) │
+│ • Add relevant links (PRs, tickets, docs)                   │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│ Human Review & Enhancement Layer                            │
+├─────────────────────────────────────────────────────────────┤
+│ • Present draft for review                                  │
+│ • Human adds context AI cannot infer                        │
+│ • Adjust priorities based on team needs                     │
+│ • Add personal notes, schedule changes                      │
+│ • Approve and post to team channel                          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Implementation Script:**
+
+```bash
+#!/bin/bash
+# generate-standup.sh - AI-powered standup note generator
+
+DATE=$(date +%Y-%m-%d)
+USER=$(git config user.name)
+USER_EMAIL=$(git config user.email)
+
+echo "🤖 Generating standup note for $USER on $DATE..."
+
+# 1. Collect Git commits
+echo "📊 Analyzing Git history..."
+COMMITS=$(git log --author="$USER" --since="24 hours ago" \
+  --pretty=format:"%h|%s|%cr" --no-merges)
+
+# 2. Query Jira (requires jira CLI)
+echo "🎫 Fetching Jira tickets..."
+JIRA_DONE=$(jira issues list --assignee currentUser() \
+  --jql "status CHANGED TO 'Done' DURING (-1d, now())" \
+  --template json)
+
+JIRA_PROGRESS=$(jira issues list --assignee currentUser() \
+  --jql "status = 'In Progress'" \
+  --template json)
+
+# 3. Get Obsidian recent changes (via MCP)
+echo "📝 Checking Obsidian vault..."
+OBSIDIAN_CHANGES=$(obsidian_get_recent_changes --days 2)
+
+# 4. Get calendar events
+echo "📅 Fetching calendar..."
+MEETINGS=$(gcal --today --format=json)
+
+# 5. Send to AI for analysis and generation
+echo "🧠 Generating standup note with AI..."
+cat << EOF > /tmp/standup-context.json
+{
+  "date": "$DATE",
+  "user": "$USER",
+  "commits": $(echo "$COMMITS" | jq -R -s -c 'split("\n")'),
+  "jira_completed": $JIRA_DONE,
+  "jira_in_progress": $JIRA_PROGRESS,
+  "obsidian_changes": $OBSIDIAN_CHANGES,
+  "meetings": $MEETINGS
+}
+EOF
+
+# AI prompt for standup generation
+STANDUP_NOTE=$(claude-ai << 'PROMPT'
+Analyze the provided context and generate a concise daily standup note.
+
+Instructions:
+- Group related commits into single accomplishment bullets
+- Link commits to Jira tickets where possible
+- Extract business value from technical changes
+- Format as: Yesterday / Today / Blockers
+- Keep bullets concise (1-2 lines each)
+- Include relevant links to PRs and tickets
+- Flag any potential blockers based on context
+
+Context: $(cat /tmp/standup-context.json)
+
+Generate standup note in markdown format.
+PROMPT
+)
+
+# 6. Save draft to Obsidian
+echo "$STANDUP_NOTE" > ~/Obsidian/Standup\ Notes/$DATE.md
+
+# 7. Present for human review
+echo "✅ Draft standup note generated!"
+echo ""
+echo "$STANDUP_NOTE"
+echo ""
+read -p "Review the draft above. Post to Slack? (y/n) " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    # 8. Post to Slack
+    slack-cli chat send --channel "#standup" --text "$STANDUP_NOTE"
+    echo "📮 Posted to Slack #standup channel"
+fi
+
+echo "💾 Saved to: ~/Obsidian/Standup Notes/$DATE.md"
+```
+
+**AI Prompt Template for Standup Generation:**
+
+```
+You are an expert at synthesizing engineering work into clear, concise standup updates.
+
+Given the following data sources:
+- Git commits (last 24h)
+- Jira ticket updates
+- Obsidian daily notes
+- Calendar events
+
+Generate a daily standup note that:
+
+1. **Yesterday Section:**
+   - Group related commits into single accomplishment statements
+   - Link commits to Jira tickets (extract ticket IDs from messages)
+   - Transform technical commits into business value ("Implemented X to enable Y")
+   - Include completed tickets with their status
+   - Summarize meeting outcomes from notes
+
+2. **Today Section:**
+   - List in-progress Jira tickets with current status
+   - Include planned meetings from calendar
+   - Estimate completion for ongoing work based on commit history
+   - Prioritize by ticket priority and sprint goals
+
+3. **Blockers Section:**
+   - Identify potential blockers from patterns:
+     * Multiple commits attempting same fix (indicates struggle)
+     * No commits on high-priority ticket (may be blocked)
+     * Comments in code mentioning "TODO" or "FIXME"
+   - Extract explicit blockers from daily notes
+   - Flag dependencies mentioned in Jira comments
+
+Format:
+- Use markdown with clear headers
+- Bullet points for each item
+- Include hyperlinks to PRs, tickets, docs
+- Keep each bullet 1-2 lines maximum
+- Add emoji for visual scanning (✅ ⚠️ 🚀 etc.)
+
+Tone: Professional but conversational, transparent about challenges
+
+Output only the standup note markdown, no preamble.
+```
+
+**Cron Job Setup (Daily Automation):**
+
+```bash
+# Add to crontab: Run every weekday at 8:45 AM
+45 8 * * 1-5 /usr/local/bin/generate-standup.sh
+
+# Sends notification when draft is ready:
+# "Your standup note is ready for review!"
+# Opens Obsidian note and prepares Slack message
+```
+
+---
+
+**Tool Version:** 2.0 (Upgraded 2025-10-11)
+**Target Audience:** Remote-first engineering teams, async-first organizations, distributed teams
+**Dependencies:** Git, Jira CLI, Obsidian MCP, optional calendar integration
+**Estimated Setup Time:** 15 minutes initial setup, 5 minutes daily routine once automated