| name | whatsapp-message-management |
| description | Use when user wants to capture tasks, send briefings, or manage life via WhatsApp - leverages existing WhatsApp MCP for mobile-first workflow |
WhatsApp Message Management
Overview
Transform WhatsApp into a powerful life management interface that works seamlessly with ExoMind's task, habit, and knowledge systems. This skill enables mobile-first workflows where you can capture thoughts, receive daily briefings, check in on habits, and manage your life through natural WhatsApp conversations.
Core principle: Meet users where they are (on their phone) with quick, actionable messages that integrate with the broader ExoMind ecosystem.
Announce at start: "I'm using the WhatsApp message management skill to help you manage your life via mobile messaging."
Quick Reference
| Phase | Key Activities | Tool Usage | Output |
|---|
| 1. Setup | Configure WhatsApp MCP connection | Check MCP server status | Connected messaging channel |
| 2. Quick Capture | Parse incoming messages for tasks/notes | mcp__whatsapp__send_message, Task creation | Captured items in system |
| 3. Daily Briefing | Generate and send morning/evening updates | Life OS skills, mcp__whatsapp__send_message | Timely briefings delivered |
| 4. Habit Check-ins | Send reminders and log responses | Habit tracking, mcp__whatsapp__send_message | Habit streaks maintained |
| 5. Contextual Queries | Answer questions using ExoMind knowledge | RAG search, mcp__whatsapp__send_message | Informed responses |
Life OS Integration
This skill integrates seamlessly with the Life OS workflow system:
- daily-planning: Get morning priorities and tasks for briefings
- weekly-review: Send weekly summaries and reflection prompts
- processing-inbox: Quick capture flows into inbox processing
- conducting-life-assessment: Track progress via daily briefings
- goal-setting: Link daily tasks to quarterly goals
When to Use
- User mentions "send me" or "message me on WhatsApp"
- Daily briefing requests ("morning summary", "evening recap")
- Quick capture scenarios ("I'll message you the task")
- Habit tracking reminders ("remind me to...")
- Mobile-first workflows
- Time-sensitive notifications
- On-the-go task management
The Pattern
Copy this checklist to track progress:
WhatsApp Management Progress:
- [ ] Phase 1: Setup (WhatsApp MCP configured and tested)
- [ ] Phase 2: Quick Capture (message parsing and task creation working)
- [ ] Phase 3: Daily Briefing (scheduled briefings configured)
- [ ] Phase 4: Habit Check-ins (reminder system active)
- [ ] Phase 5: Contextual Queries (RAG integration functional)
Phase 1: Setup & Connection
Verify WhatsApp MCP is available:
- Check MCP server connection status
- Test send/receive capabilities
- Configure user's phone number if needed
- Set up Do Not Disturb hours (default: 22:00-07:00)
Example verification:
claude mcp list | grep whatsapp
Phase 2: Quick Capture (Enhanced)
Parse incoming WhatsApp messages for tasks and notes:
Capture patterns to recognize:
- Task indicators: "remind me", "todo", "task:", "I need to"
- Note indicators: "note:", "remember", "idea:"
- Voice note indicators: "voice memo", "audio note"
- Photo indicators: Image attachments
- Context indicators: "@work", "@home", "#project-name"
- Priority indicators: "urgent", "important", "!!!"
Enhanced Processing Workflow:
mcp__whatsapp__list_messages({
after: lastCheckTime,
limit: 20
});
async function parseQuickCapture(message) {
if (message.hasAudio) {
const transcription = await transcribeVoiceNote(message.audioPath);
return parseTaskFromText(transcription);
}
if (message.hasImage) {
const imageContext = await analyzeImage(message.imagePath);
return {
type: 'note',
content: message.caption || 'Visual reference',
attachment: message.imagePath,
context: imageContext
};
}
return parseTaskFromText(message.text);
}
async function quickCaptureToInbox(parsedItem) {
const inboxItem = {
content: parsedItem.content,
type: parsedItem.type,
context: parsedItem.context,
priority: parsedItem.priority,
tags: parsedItem.tags,
source: 'whatsapp',
capturedAt: new Date(),
attachment: parsedItem.attachment
};
await addToInbox(inboxItem);
await mcp__whatsapp__send_message({
recipient: parsedItem.userPhone,
message: formatConfirmation(inboxItem)
});
}
Enhanced Capture Examples:
Text Capture:
User (WhatsApp): "Remind me to call dentist tomorrow @health"
ExoMind: "✓ Task added to inbox: Call dentist
Due: Tomorrow | Context: health
Process inbox? Reply 'inbox'"
Voice Note Capture:
User (WhatsApp): [Sends voice note: "Remember to buy milk, eggs, and bread on the way home"]
ExoMind: "🎤 Voice note captured and transcribed:
✓ Task added to inbox: Buy milk, eggs, and bread
Context: errands
Process now? Reply 'yes'"
Photo Capture:
User (WhatsApp): [Sends photo of whiteboard with caption "Project ideas from today's meeting"]
ExoMind: "📸 Photo note saved:
'Project ideas from today's meeting'
✓ Added to inbox with visual reference
View later: Reply 'show photos'"
Quick Batch Capture:
User (WhatsApp): "todo: buy groceries, call mom, schedule dentist @personal"
ExoMind: "✓ 3 tasks added to inbox:
1. Buy groceries
2. Call mom
3. Schedule dentist
Context: personal | Ready to process? Reply 'inbox'"
Integration with processing-inbox skill:
All quick captures flow into the inbox processing workflow:
- Capture via WhatsApp → Inbox
- User processes inbox (mobile or desktop)
- Items converted to tasks, events, or notes
- Context and priority preserved throughout
Phase 3: Daily Briefing (Life OS Integration)
Morning Briefing Template (07:00-09:00):
Uses daily-planning skill to generate structured morning briefing:
const morningBriefing = {
priorities: [],
calendar: [],
habits: [],
energy: null,
focus: null
};
mcp__whatsapp__send_message({
recipient: userPhoneNumber,
message: formatMorningBriefing(morningBriefing)
});
Morning Message Format:
☀️ Good morning! {Day}, {Date}
🎯 TOP 3 PRIORITIES:
1. ⚡ {Priority Task 1} ({Time estimate})
2. ⚡ {Priority Task 2} ({Time estimate})
3. ⚡ {Priority Task 3} ({Time estimate})
📅 NEXT 3 MEETINGS:
• {Meeting 1} at {Time}
• {Meeting 2} at {Time}
• {Meeting 3} at {Time}
✅ PENDING TASKS: {Count}
🔄 HABITS: {Count to complete}
💡 Focus: {Today's main focus area}
⚡ Energy: {Yesterday's energy level}
Reply "done" + number to check off
Reply "plan" for full daily plan
Evening Briefing Template (18:00-20:00):
Uses daily-planning skill for retrospective:
const eveningBriefing = {
wins: [],
tasksCompleted: 0,
habitsCompleted: 0,
energy: null,
reflection: null,
tomorrow: []
};
mcp__whatsapp__send_message({
recipient: userPhoneNumber,
message: formatEveningBriefing(eveningBriefing)
});
Evening Message Format:
🌙 Evening recap - {Day}
🎉 TODAY'S WINS (min 3):
1. {Win 1}
2. {Win 2}
3. {Win 3}
✅ COMPLETED:
• {X} tasks finished
• {X} habits maintained
🔥 Active streaks: {List streaks}
⚡ ENERGY CHECK:
How was your energy today? (1-5)
Reply with number
💭 REFLECTION:
{Reflection prompt based on weekly theme}
🔜 TOMORROW PREVIEW:
Top priority: {Tomorrow's #1 task}
Reply "reflect" to share insights
Reply "wins" to add more wins
Weekly Briefing (Sunday Evening):
Uses weekly-review skill:
const weeklyBriefing = {
weekSummary: {},
goalProgress: [],
nextWeekFocus: null,
habits: {},
reflection: null
};
mcp__whatsapp__send_message({
recipient: userPhoneNumber,
message: formatWeeklyBriefing(weeklyBriefing)
});
Weekly Message Format:
📊 WEEK {Number} SUMMARY
✅ ACCOMPLISHED:
• {X} tasks completed
• {X} habits maintained
• {Key achievements}
🎯 GOAL PROGRESS:
• {Goal 1}: {X}% complete
• {Goal 2}: {X}% complete
• {Goal 3}: {X}% complete
🔥 HABIT STREAKS:
• {Habit 1}: {X} days
• {Habit 2}: {X} days
• {Habit 3}: {X} days
🔜 NEXT WEEK FOCUS:
{Main focus area for upcoming week}
💭 WEEKLY REFLECTION:
{Reflection prompt for weekly review}
Ready for weekly review? Reply "review"
Phase 4: Habit Check-ins
Reminder scheduling:
- Send reminders at configured times
- Track responses for habit completion
- Maintain streak counts
- Send encouragement for milestones
Smart reminder logic:
- Don't remind if already completed today
- Adjust timing based on completion patterns
- Scale back frequency if consistently completed
- Send encouragement on long streaks
Example interaction:
ExoMind (15:00): "🏃 Time for your afternoon walk! 7-day streak 🔥"
User: "done"
ExoMind: "✅ Walk logged! Streak: 8 days. You're crushing it!"
ExoMind (21:00): "📖 Evening reading reminder - 30 minutes to hit your goal"
User: "skip today, busy"
ExoMind: "No problem! Your 12-day streak is safe. We'll catch up tomorrow."
Phase 5: Contextual Queries
Handle questions and requests:
- Use RAG to search knowledge base
- Pull relevant task/habit context
- Provide concise, mobile-friendly answers
- Offer follow-up actions
Query patterns:
- "What tasks do I have for [project]?"
- "Show me my [habit] streak"
- "What did I note about [topic]?"
- "When is [task] due?"
Example:
User: "What tasks do I have for the website project?"
ExoMind: "🌐 Website Project (3 tasks):
1. ⚡ Design homepage mockup (Due: Fri)
2. Write copy for About page (Due: Next week)
3. Set up hosting (No due date)
Want to see details for any of these?"
Integration
WhatsApp MCP Tools
Primary interface for all messaging:
mcp__whatsapp__send_message({
recipient: "1234567890",
message: "Your briefing text here"
});
mcp__whatsapp__send_file({
recipient: "1234567890",
media_path: "/absolute/path/to/file.jpg"
});
mcp__whatsapp__send_audio_message({
recipient: "1234567890",
media_path: "/absolute/path/to/audio.ogg"
});
mcp__whatsapp__list_messages({
after: "2025-01-15T00:00:00Z",
limit: 20,
include_context: true
});
mcp__whatsapp__search_contacts({
query: "John"
});
mcp__whatsapp__download_media({
message_id: "msg_123",
chat_jid: "1234567890@s.whatsapp.net"
});
Life OS Skill Integration
daily-planning skill:
const dailyPlan = await getDailyPlan(userId);
const morningBriefing = formatMorningBriefing({
priorities: dailyPlan.topThree,
meetings: dailyPlan.calendar,
habits: dailyPlan.activeHabits
});
await mcp__whatsapp__send_message({
recipient: userPhone,
message: morningBriefing
});
weekly-review skill:
const weeklyReview = await getWeeklyReview(userId);
const weeklyBriefing = formatWeeklyBriefing({
summary: weeklyReview.achievements,
goalProgress: weeklyReview.goals,
nextWeek: weeklyReview.nextFocus
});
await mcp__whatsapp__send_message({
recipient: userPhone,
message: weeklyBriefing
});
processing-inbox skill:
const capturedItem = parseQuickCapture(whatsappMessage);
await addToInbox(capturedItem);
await mcp__whatsapp__send_message({
recipient: userPhone,
message: "✓ Added to inbox for processing"
});
conducting-life-assessment skill:
const energyCheck = await promptEnergyRating(userPhone);
const reflection = await promptReflection(userPhone);
await updateLifeAssessment(userId, {
energy: energyCheck,
reflection: reflection,
date: new Date()
});
goal-setting skill:
const goals = await getQuarterlyGoals(userId);
const todaysTasks = await getDailyTasks(userId);
const goalLinkedTasks = linkTasksToGoals(todaysTasks, goals);
const briefing = formatMorningBriefing({
priorities: goalLinkedTasks,
goalContext: goals
});
ExoMind Components
- Task Manager: Create, update, complete tasks from messages
- Habit Tracker: Log completions, check streaks, send reminders
- Knowledge Base (RAG): Search notes and context for queries
- Calendar Integration: Pull events for briefings
- User Preferences: DND hours, notification frequency, message style
- Inbox System: Quick capture flows into processing workflow
Common Use Cases
Use Case 1: Morning Commute Quick Capture
Scenario: User is on the train, thinks of three tasks
User: "todo: buy groceries, call mom, schedule dentist @personal"
ExoMind: "✓ Created 3 tasks in Personal context:
1. Buy groceries
2. Call mom
3. Schedule dentist
All added to your inbox for processing."
Use Case 2: Daily Briefing Workflow
Morning (07:30):
ExoMind: "☀️ Good morning! Tuesday, Jan 15
📋 Today's Focus (3 tasks):
1. ⚡ Submit quarterly report (Due today)
2. Review team feedback
3. Prep for 2pm client call
🎯 Habits: Meditation, Exercise, Reading
Ready to crush it? Reply 'done 1' to check off tasks."
Evening (19:00):
ExoMind: "🌙 Evening recap:
✅ Completed: 2 tasks, 3 habits
🔥 Streaks maintained: Meditation (45d), Reading (12d)
Tomorrow's priority: Finish marketing presentation
How did today go? (Great/Good/Tough)"
Use Case 3: Habit Accountability
Scenario: User building a meditation habit
Day 1 (07:00): "🧘 Morning meditation time! Starting your new habit."
User: "done"
ExoMind: "✅ Great start! Day 1 complete."
Day 7 (07:00): "🧘 Morning meditation - 7 day streak! 🔥"
User: "done"
ExoMind: "✅ Week 1 complete! You're building a solid habit."
Day 30 (07:00): "🧘 Meditation time! 30-DAY MILESTONE! 🎉"
User: "done"
ExoMind: "✅ 30 DAYS! This is now part of who you are. Amazing work!"
Use Case 4: Context-Aware Note Capture
Scenario: User learns something valuable
User: "Note: React useCallback only needed when passing callbacks to optimized child components - don't overuse #dev #react"
ExoMind: "✓ Note saved with tags: dev, react
Connected to 3 related notes in your knowledge base.
Want to see related content?"
User: "yes"
ExoMind: "Related notes:
1. React performance optimization patterns
2. When to use useMemo vs useCallback
3. React re-render debugging guide
Reply with number to view full note."
Use Case 5: Project Context Switching
Scenario: User needs to focus on specific project
User: "Show me everything for website redesign project"
ExoMind: "🌐 Website Redesign Project:
📋 Tasks (5):
• Design homepage (Due: Thu) ⚡
• Write new copy (Due: Next week)
• Set up hosting (No due date)
• Configure analytics (No due date)
• Mobile testing (Blocked - needs design)
📝 Recent Notes: 2
🔗 Related Habits: Daily design review
What would you like to focus on?"
Red Flags
Do Not:
- Spam messages - Respect user's attention and DND hours
- Send long messages - Keep everything scannable on mobile
- Ignore context - Remember conversation history within session
- Be overly formal - Match user's communication style
- Send during DND hours - Default 22:00-07:00, user configurable
- Over-notify - Bundle related updates together
- Lose messages - Always confirm receipt and action taken
Warning Signs:
- User says "too many messages" → Reduce frequency
- Messages go unread for days → Adjust timing or format
- User always uses "skip" on habits → Habit may not be right
- Repeated "I already did this" → Check for duplicate tracking
- User stops responding → Too much noise, dial back
Message Style Guide
Tone:
- Encouraging but not pushy: "Time for your walk 🏃" not "You MUST walk now!"
- Celebratory on wins: "7-day streak! 🔥" with emojis
- Understanding on misses: "No problem, we'll catch up tomorrow"
- Concise and scannable: Bullets, numbers, emojis for quick reading
Formatting:
- Emojis for context: ✅ (done), ⚡ (urgent), 🔥 (streak), 📋 (tasks)
- Numbers for quick action: "Reply 'done 1' to mark complete"
- Line breaks for readability: Never send walls of text
- Bold for key info: Limited use, important items only
Response Patterns:
Confirmation: "✓ [Action completed]"
Celebration: "✅ [Achievement] 🎉"
Reminder: "🔔 [Habit/Task] - [Context]"
Query result: "📋 [Category]: [List]"
Error: "❌ [Issue] - [What to do]"
Technical Implementation Notes
Message Parsing (Enhanced)
async function parseQuickCapture(message) {
const patterns = {
task: /^(todo:|task:|remind me to)/i,
note: /^(note:|remember:|idea:)/i,
habit: /^(done|complete|skip|did)/i,
query: /^(show|what|when|find|plan)/i,
context: /@(\w+)/g,
tags: /#(\w+)/g,
priority: /(!{1,3}|urgent|important|asap)/i,
voiceNote: message.hasAudio,
photo: message.hasImage
};
if (patterns.voiceNote) {
const audioPath = await mcp__whatsapp__download_media({
message_id: message.id,
chat_jid: message.chatJid
});
const transcription = await transcribeAudio(audioPath.file_path);
message.text = transcription;
}
if (patterns.photo) {
const imagePath = await mcp__whatsapp__download_media({
message_id: message.id,
chat_jid: message.chatJid
});
return {
type: 'note',
content: message.caption || 'Visual reference',
attachment: imagePath.file_path,
source: 'whatsapp'
};
}
const type = Object.keys(patterns).find(key =>
patterns[key] instanceof RegExp && patterns[key].test(message.text)
);
const contexts = [...message.text.matchAll(patterns.context)].map(m => m[1]);
const tags = [...message.text.matchAll(patterns.tags)].map(m => m[1]);
const hasPriority = patterns.priority.test(message.text);
return {
type: type || 'task',
content: message.text.replace(patterns[type] || '', '').trim(),
contexts,
tags,
priority: hasPriority ? 'high' : 'normal',
source: 'whatsapp',
timestamp: message.timestamp
};
}
Briefing Generation with Life OS Integration
async function generateMorningBriefing(userId) {
const dailyPlan = await getDailyPlan(userId);
const calendar = await getCalendarEvents(userId, 'today');
const habits = await getActiveHabits(userId);
const energy = await getLastEnergyLevel(userId);
const briefing = `☀️ Good morning! ${formatDate('today')}
🎯 TOP 3 PRIORITIES:
${dailyPlan.priorities.slice(0, 3).map((t, i) =>
`${i + 1}. ⚡ ${t.title} (${t.timeEstimate})`
).join('\n')}
📅 NEXT 3 MEETINGS:
${calendar.slice(0, 3).map(e =>
`• ${e.title} at ${formatTime(e.start)}`
).join('\n')}
✅ PENDING TASKS: ${dailyPlan.pendingCount}
🔄 HABITS: ${habits.filter(h => !h.completedToday).length}
💡 Focus: ${dailyPlan.mainFocus}
⚡ Energy: ${energy ? energy.level + '/5' : 'Not tracked'}
Reply "done" + number to check off
Reply "plan" for full daily plan`;
return briefing;
}
async function generateEveningBriefing(userId) {
const completed = await getCompletedTasks(userId, 'today');
const habits = await getCompletedHabits(userId, 'today');
const streaks = await getActiveStreaks(userId);
const tomorrow = await getTomorrowPriorities(userId);
const reflectionPrompt = await getReflectionPrompt(userId);
const briefing = `🌙 Evening recap - ${formatDate('today')}
🎉 TODAY'S WINS (min 3):
${completed.slice(0, 3).map((t, i) =>
`${i + 1}. ${t.title}`
).join('\n')}
✅ COMPLETED:
• ${completed.length} tasks finished
• ${habits.length} habits maintained
🔥 Active streaks: ${streaks.map(s => s.name + ' (' + s.days + 'd)').join(', ')}
⚡ ENERGY CHECK:
How was your energy today? (1-5)
Reply with number
💭 REFLECTION:
${reflectionPrompt}
🔜 TOMORROW PREVIEW:
Top priority: ${tomorrow[0]?.title || 'Not set'}
Reply "reflect" to share insights
Reply "wins" to add more wins`;
return briefing;
}
async function generateWeeklyBriefing(userId) {
const weekReview = await getWeeklyReview(userId);
const goalProgress = await getGoalProgress(userId);
const habitStats = await getWeeklyHabitStats(userId);
const briefing = `📊 WEEK ${weekReview.weekNumber} SUMMARY
✅ ACCOMPLISHED:
• ${weekReview.tasksCompleted} tasks completed
• ${weekReview.habitsCompleted} habits maintained
• ${weekReview.keyAchievements.join('\n• ')}
🎯 GOAL PROGRESS:
${goalProgress.map(g =>
`• ${g.name}: ${g.progress}% complete`
).join('\n')}
🔥 HABIT STREAKS:
${habitStats.map(h =>
`• ${h.name}: ${h.streak} days`
).join('\n')}
🔜 NEXT WEEK FOCUS:
${weekReview.nextWeekFocus}
💭 WEEKLY REFLECTION:
${weekReview.reflectionPrompt}
Ready for weekly review? Reply "review"`;
return briefing;
}
Scheduling
const cron = require('node-cron');
cron.schedule('30 7 * * *', async () => {
const users = await getActiveUsers();
for (const user of users) {
if (!isInDNDHours(user)) {
const briefing = await generateMorningBriefing(user.id);
await mcp__whatsapp__send_message({
recipient: user.phone,
message: briefing
});
}
}
}, {
timezone: user.timezone
});
cron.schedule('0 19 * * *', async () => {
const users = await getActiveUsers();
for (const user of users) {
if (!isInDNDHours(user)) {
const briefing = await generateEveningBriefing(user.id);
await mcp__whatsapp__send_message({
recipient: user.phone,
message: briefing
});
}
}
}, {
timezone: user.timezone
});
cron.schedule('0 18 * * 0', async () => {
const users = await getActiveUsers();
for (const user of users) {
if (!isInDNDHours(user)) {
const briefing = await generateWeeklyBriefing(user.id);
await mcp__whatsapp__send_message({
recipient: user.phone,
message: briefing
});
}
}
}, {
timezone: user.timezone
});
State Management
- Track conversation context within session
- Remember last 10 interactions for continuity
- Clear session after 30 minutes of inactivity
- Persist user preferences across sessions
- Store briefing history for pattern analysis
- Link WhatsApp interactions to Life OS data
Privacy & Security
- No message logging - Process and discard, don't store full messages
- Secure MCP connection - Encrypted transport
- User data stays local - Only send what's necessary to WhatsApp
- Opt-in by default - User must enable WhatsApp integration
- Easy opt-out - "pause notifications" command anytime
Examples
Example 1: Full Morning Routine
[07:30 - Automated briefing]
ExoMind: "☀️ Good morning! Wednesday, Jan 16
📋 Today's Focus (4 tasks):
1. ⚡ Submit budget review (Due today)
2. Team standup at 10am
3. Review marketing materials
4. Plan weekend trip
🎯 Habits: Meditation, Exercise, Reading, Water intake
🌤️ Weather: Sunny, 72°F
Reply 'done' + number to check off tasks."
[07:45 - User interaction]
User: "done meditation"
ExoMind: "✅ Meditation complete! 46-day streak 🔥"
[08:30 - Quick capture]
User: "todo: book restaurant for anniversary @personal !!"
ExoMind: "✓ High priority task created: Book restaurant for anniversary
Added to Personal context. Due date?"
User: "friday"
ExoMind: "✓ Due date set: This Friday, Jan 18"
[12:00 - Contextual query]
User: "what's my afternoon looking like?"
ExoMind: "📋 Afternoon (3 items):
• Team standup at 10am ✅ (passed)
• Review marketing materials (Due today)
• Plan weekend trip (No due date)
You're on track! 🎯"
Example 2: Habit Building Journey
[Week 1]
Day 1: "🏃 Afternoon walk reminder - let's start strong!"
User: "done"
ExoMind: "✅ Day 1 complete! Great start."
Day 3: "🏃 Walk time! You're 3 for 3 🔥"
User: "skip today, raining"
ExoMind: "No problem! Weather happens. Tomorrow's a new day."
Day 4: "🏃 Back at it! 3-day streak still alive."
User: "done"
ExoMind: "✅ Resilience! That's how habits stick."
[Week 4]
Day 28: "🏃 Walk time - almost at 30 days! 🔥"
User: "done"
ExoMind: "✅ 28 days! Weekend milestone coming up! 🎉"
[Month 2]
Day 60: "🏃 2-MONTH MILESTONE! 🎉 You've walked 60 days!"
User: "done"
ExoMind: "✅ 60 DAYS! This is officially who you are now. Incredible!"
Example 3: Project-Based Workflow
User: "Starting work on mobile app project"
ExoMind: "📱 Mobile App Project activated.
Current status:
📋 5 tasks (2 urgent)
📝 8 notes in knowledge base
🔗 Related: UI design habit
Want the task breakdown?"
User: "yes"
ExoMind: "📋 Mobile App Tasks:
1. ⚡ Fix login bug (Due today)
2. ⚡ Review PR #234 (Due today)
3. Design settings screen (Due Fri)
4. Write API docs (Next week)
5. User testing prep (No date)
Start with #1? Reply 'done 1' when complete."
[Later that day]
User: "done 1"
ExoMind: "✅ Login bug fixed!
⚡ Next up: Review PR #234
4 tasks remaining on Mobile App"
User: "note: Login issue was OAuth token expiration, fixed by refreshing tokens every 55min instead of 60min #mobile-app #auth"
ExoMind: "✓ Technical note saved!
Auto-tagged: mobile-app, auth
Connected to 2 related notes.
Back to PR #234 review?"
Life OS Command Reference
Quick commands users can send via WhatsApp:
Briefing Commands
"morning" or "briefing" - Get current morning briefing"evening" or "recap" - Get evening recap"weekly" - Get weekly summary"plan" - Get full daily plan
Task Management
"done 1" - Mark task #1 as complete"done [task name]" - Mark named task as complete"tasks" - List all pending tasks"todo: [task]" - Quick add task to inbox
Habit Tracking
"done [habit]" - Log habit completion"skip [habit]" - Skip habit for today"streaks" - Show all active streaks"habits" - List today's habits
Inbox Processing
"inbox" - Show inbox count"process" - Start inbox processing"capture: [item]" - Quick capture to inbox
Energy & Reflection
"energy [1-5]" - Log energy level"reflect" - Start reflection prompt"wins" - Add today's wins"wins [text]" - Quick add win
Context & Projects
"show [project]" - Show project tasks"focus [area]" - Set focus area"context @[name]" - Switch context
Weekly Review
"review" - Start weekly review"goals" - Show goal progress"next week" - Set next week focus
Success Metrics
Track these to optimize the system:
- Message response rate (target: >80%)
- Time to task capture (<30 seconds)
- Briefing read rate (target: >90%)
- Habit completion rate improvement
- User satisfaction with notification timing
- Average session length
- "Too many messages" complaints (target: <5%)
Iterate based on:
- User feedback on timing and frequency
- Completion patterns (morning vs evening people)
- Response times (adjust send times)
- Habit streaks (celebrate more, remind less as habits stick)
