communication-tracker

---
name: communication-tracker
description: Track and integrate external communications (emails, chat messages, screenshots) into project context with timeline management. Use when user mentions "email", "message", "communication", "screenshot", "track", "import", "sync", or wants to import external information sources into the project timeline.
---

# Communication Tracker Skill

## When to use this Skill

Activate when the user:
- Mentions importing or tracking emails, messages, or communications
- Uses keywords: "email", "message", "communication", "screenshot", "chat log", "track", "import"
- Provides image files (screenshots of emails/chats)
- Wants to record external communication updates
- Mentions "import communication", "track message", "record email"
- References specific communication sources (Slack, Teams, Gmail, etc.)
- Asks to add timeline entries from external sources
- Pastes email content or chat logs

## Tools Available

This Skill uses the following tools for content extraction:
- **`mu`**: Email indexer for reading email content from local maildir
- **Claude Vision**: Direct image reading for screenshots
- **`markitdown`**: Convert various file formats to markdown (PDF, DOCX, XLSX, etc.)

## Workflow

### Phase 0: First-Time Configuration (One-Time Setup)

**Objective**: Configure communication tracking preferences on first use.

**Trigger**: This phase activates only if `communications/config.yaml` does not exist.

**Steps**:

1. **Detect first-time use**:
   ```bash
   ls communications/config.yaml
   ```
   If file doesn't exist → Proceed with configuration Q&A.

2. **Ask configuration questions** using AskUserQuestion tool:

   **Question 1: Timeline Tracking**:
   ```
   Timeline Configuration

   Should I create a dedicated timeline tracking file?
   This helps maintain chronological order of all communications.

   Options:
   1. Yes, create timeline.yaml (structured, machine-readable)
   2. Yes, create timeline.md (human-readable markdown)
   3. Yes, create both formats (Recommended)
   4. No, embed timeline in individual files only
   ```

   **Question 2: Original Data Backup**:
   ```
   Original Data Backup

   Should I backup original source data?
   This preserves unprocessed content for reference.

   Options:
   1. Yes, always backup originals in raw/ subdirectory (Recommended)
   2. Yes, only for images/attachments
   3. No, extract content only (no backup)
   ```

   **Question 3: Default Source Types**:
   ```
   Communication Sources

   What types of communications do you typically track?
   (Select all that apply)

   - Email (Gmail, Outlook, etc.)
   - Chat (Slack, Teams, Discord)
   - Screenshots (any visual capture)
   - Voice/Meeting transcripts
   - Documents
   ```

   **Question 4: Timestamp Handling**:
   ```
   Timestamp Handling

   How should I handle communications without clear timestamps?

   Options:
   1. Always ask user for the timestamp
   2. Use current time with "[estimated]" marker
   3. Try to infer from content, ask if uncertain (Recommended)
   ```

3. **Generate config.yaml**:
   ```yaml
   # communications/config.yaml
   # Generated by ProjectMaster communication-tracker Skill

   timeline:
     enabled: true
     format: both  # yaml|md|both|none
     file: timeline

   backup:
     enabled: true
     mode: all  # all|attachments|none
     directory: raw/

   sources:
     - email
     - chat
     - screenshot
     - document

   timestamp_handling:
     mode: infer  # ask|estimate|infer
     marker_for_estimated: "[estimated]"

   # Auto-generated
   created: YYYY-MM-DD
   last_updated: YYYY-MM-DD
   ```

4. **Create directory structure**:
   ```bash
   mkdir -p communications/raw communications/by-source communications/by-date
   ```

5. **Create initial files**:
   - `communications/README.md` - Index of all communications
   - `communications/timeline.yaml` - Machine-readable timeline
   - `communications/timeline.md` - Human-readable timeline

6. **Report configuration complete**:
   ```
   Communication Tracker Configured!

   Structure created:
   communications/
   ├── config.yaml (your preferences)
   ├── README.md (index)
   ├── timeline.yaml (chronological tracking)
   ├── timeline.md (human-readable timeline)
   ├── raw/ (original data backup)
   ├── by-source/ (organized by source type)
   └── by-date/ (organized by date)

   Ready to track communications! Try:
   - "Track this email: [paste content]"
   - "Import screenshot [provide image path]"
   - "Record communication from Slack about [topic]"
   ```

### Phase 1: Context Discovery & Source Detection

**Objective**: Understand project context and identify communication source type.

**Steps**:

1. **Read project RULE.md**:
   ```bash
   ls RULE.md
   Read RULE.md
   ```
   Extract communication tracking preferences if defined.

2. **Read communications/config.yaml**:
   ```bash
   Read communications/config.yaml
   ```
   If not found → Trigger Phase 0 first.

3. **Detect source type from user input**:

   | Input Pattern | Source Type | Detection Method |
   |--------------|-------------|------------------|
   | Image file path (.png, .jpg, .gif) | screenshot | File extension detection |
   | `mu` output or email headers (From:, To:, Date:, Subject:) | email | Header pattern matching |
   | Text with chat format (timestamps + usernames) | chat | Timestamp/username patterns |
   | Markdown/text file | document | File content structure |
   | PDF, DOCX, XLSX | document | File extension + markitdown |
   | User describes source | manual | Ask for clarification |

4. **Route to appropriate extraction workflow**:
   - Source: screenshot → Phase 2A (Image Processing)
   - Source: email → Phase 2B (Email Processing)
   - Source: text/chat → Phase 2C (Text Processing)
   - Source: file → Phase 2D (File Processing)

**Example**:
```
User: "Track this email from the client about project updates"

Detected:
- Source type: email
- Content: [email text provided by user]
- Related: project updates
→ Route to Phase 2B (Email Processing)
```

### Phase 2A: Image Processing (Screenshots)

**Objective**: Extract information from screenshot images.

**Steps**:

1. **Read image using Claude's vision**:
   ```
   Use Read tool with image file path
   Claude will analyze the image content
   ```

2. **Extract structured information**:
   - **Source platform**: (Gmail, Slack, Teams, WhatsApp, LINE, etc.)
   - **Participants**: (sender, recipients, @mentions)
   - **Timestamp**: (look for date/time in image)
   - **Subject/Topic**: (email subject, channel name, etc.)
   - **Key content**: (main message body)
   - **Attachments mentioned**: (if visible)
   - **Thread context**: (is this a reply? part of conversation?)

3. **Handle timestamp extraction**:
   ```
   If timestamp clearly visible in image:
     → Extract and validate format
   If timestamp partially visible or ambiguous:
     → Show extracted timestamp, ask user to confirm
   If no timestamp visible:
     → Check config.yaml timestamp_handling mode
     → If "ask": Ask user for timestamp
     → If "estimate": Use current time with [estimated] marker
     → If "infer": Try to infer from context, ask if uncertain
   ```

4. **Confirm extraction with user**:
   ```
   Screenshot Analysis Complete

   I extracted the following information:

   Source: [Platform - e.g., Gmail]
   From: [Sender]
   To: [Recipients]
   Date: [Timestamp or "Unable to determine - please provide"]
   Subject: [Topic]

   Content Summary:
   [Key points from the communication]

   Is this correct? Any corrections needed?
   [If timestamp missing: "When was this communication from?"]
   ```

5. **Backup original image** (if config.yaml backup.enabled):
   ```bash
   cp [image_path] communications/raw/YYYY-MM-DD_source_filename.png
   ```

### Phase 2B: Email Processing

**Objective**: Extract and structure email content.

**Steps**:

1. **Determine email source**:
   - If user provides raw text → Parse directly
   - If user mentions `mu` → Use mu command to fetch
   - If user provides file path (.eml) → Read file

2. **Use `mu` for email fetching** (if applicable):
   ```bash
   # Search for specific email
   mu find subject:[search term] --format=sexp

   # View specific email
   mu view [message-id]
   ```

3. **Extract email metadata**:
   ```yaml
   from: [sender email and name]
   to: [recipient list]
   cc: [cc list]
   date: [email date from headers]
   subject: [subject line]
   message_id: [unique identifier]
   thread_id: [conversation thread]
   attachments: [list of attachments]
   ```

4. **Extract email body**:
   - Convert HTML to markdown (if HTML email)
   - Preserve formatting and links
   - Extract inline images references

5. **Identify key information**:
   - Action items mentioned
   - Decisions communicated
   - Questions asked
   - Deadlines mentioned
   - People referenced (@mentions, names)

6. **Backup original** (if configured):
   ```bash
   # Save raw email to backup
   mu view [message-id] > communications/raw/YYYY-MM-DD_email_subject-slug.eml
   ```

### Phase 2C: Text/Chat Processing

**Objective**: Process plain text or chat message content.

**Steps**:

1. **Detect chat format**:
   - Slack format: `[timestamp] username: message`
   - Teams format: `username timestamp message`
   - Discord format: `username timestamp message`
   - LINE format: `YYYY/MM/DD HH:MM name message`
   - Generic: timestamps + usernames

2. **Parse conversation**:
   ```yaml
   platform: [detected or ask]
   channel_dm: [if identifiable]
   participants: [list of usernames]
   date_range:
     start: YYYY-MM-DDTHH:MM
     end: YYYY-MM-DDTHH:MM
   messages:
     - timestamp: [time]
       sender: [username]
       content: [message]
   ```

3. **Handle multi-message threads**:
   - Group related messages
   - Identify thread starts and replies
   - Extract thread summary

4. **Ask for missing context** if needed:
   ```
   I parsed this chat conversation but need clarification:

   - Platform: [Ask if not detected]
   - Channel/Context: [Ask if not clear]
   - Date: [Ask if timestamps are relative like "yesterday"]
   ```

### Phase 2D: File Processing (markitdown)

**Objective**: Process various file formats using markitdown.

**Steps**:

1. **Identify file type**:
   - PDF documents
   - Word documents (.docx)
   - Excel spreadsheets (.xlsx)
   - Other supported formats

2. **Use markitdown for conversion**:
   ```bash
   markitdown [file_path]
   ```

3. **Extract metadata from converted content**:
   - Document title
   - Author (if available)
   - Creation/modification date
   - Key content sections

4. **Handle conversion errors**:
   - If markitdown fails, report error
   - Suggest alternative approaches
   - Offer to save original file as-is

### Phase 3: Timestamp Validation & Normalization

**Objective**: Ensure all communications have valid, normalized timestamps.

**Steps**:

1. **Normalize timestamp format**:
   - Target format: `YYYY-MM-DDTHH:MM:SS+TZ` (ISO 8601)
   - Preserve original timezone if available
   - Convert relative times ("yesterday", "2 hours ago") to absolute

2. **Validate timestamp**:
   - Not in the future (unless explicitly stated)
   - Within reasonable range for source type
   - Consistent with thread context

3. **If timestamp uncertain** (based on config.yaml timestamp_handling):
   ```
   Timestamp Clarification Needed

   I couldn't determine an exact timestamp from the content.

   The communication appears to be from approximately:
   [Best guess based on context]

   Please provide the actual date/time, or confirm this estimate:
   - Exact: "2025-12-10 14:30"
   - Approximate: "last Tuesday afternoon"
   - Confirm estimate: "yes, that's correct"
   ```

4. **Store timestamp with confidence level**:
   ```yaml
   timestamp:
     value: 2025-12-10T14:30:00+08:00
     confidence: exact|inferred|estimated
     original_format: "[as found in source]"
   ```

### Phase 4: Content Structuring

**Objective**: Structure extracted content into standardized format.

**Steps**:

1. **Generate communication document**:

   **Filename convention**:
   `YYYY-MM-DD_HH-MM_source_subject-slug.md`

   **Document structure**:
   ```markdown
   ---
   id: comm-{uuid}
   type: email|chat|screenshot|document
   source: [platform/origin]
   timestamp: YYYY-MM-DDTHH:MM:SS+TZ
   timestamp_confidence: exact|inferred|estimated
   participants:
     from: [sender]
     to: [recipients]
   subject: [topic/subject]
   related_sprint: [sprint-number or null]
   related_milestone: [milestone-id or null]
   related_communications: [list of related comm-ids]
   tags: [auto-generated tags]
   backup_file: [path to original if backed up]
   ---

   # [Subject/Topic]

   **Date**: [Human readable timestamp]
   **Source**: [Platform/Origin]
   **From**: [Sender]
   **To**: [Recipients]

   ## Content

   [Extracted/converted content in markdown]

   ## Key Points

   - [Automatically extracted key points]
   - [Important decisions or updates]
   - [Action items mentioned]

   ## Context

   [How this relates to the project]

   ## References

   - Related Sprint: [link if applicable]
   - Related Milestone: [link if applicable]
   - Previous Communication: [link if part of thread]

   ---
   *Tracked by ProjectMaster communication-tracker Skill*
   *Original backup: [path or "not backed up"]*
   ```

2. **Auto-extract key points**:
   - Action items (look for "need to", "please", "todo", etc.)
   - Decisions (look for "decided", "will proceed", "agreed", etc.)
   - Questions (look for "?" or question patterns)
   - Deadlines (look for dates, "by Friday", etc.)

3. **Auto-generate tags**:
   - Based on content analysis
   - Project-specific keywords from RULE.md
   - People mentioned
   - Topics detected

### Phase 5: Timeline Integration

**Objective**: Add communication to project timeline.

**Steps**:

1. **Read current timeline files**:
   ```bash
   Read communications/timeline.yaml
   Read communications/timeline.md
   ```

2. **Add entry to timeline.yaml**:
   ```yaml
   timeline:
     - id: comm-{uuid}
       timestamp: 2025-12-10T14:30:00+08:00
       timestamp_confidence: exact
       type: email
       source: Gmail
       subject: "Project Update from Client"
       from: [email protected]
       summary: "Client approved Phase 2 designs with minor revisions"
       file: communications/by-date/2025-12/2025-12-10_14-30_email_project-update.md
       related:
         sprint: sprint-05
         milestone: beta-release
         thread: comm-previous-id
       tags: [client, approval, design]
       key_points:
         - "Design approved with 3 minor revisions"
         - "Deadline: Dec 15 for revisions"
       action_items:
         - "Implement revision 1: color scheme update"
         - "Implement revision 2: font size adjustment"
   ```

3. **Add entry to timeline.md** (human-readable):
   ```markdown
   ## 2025-12-10

   ### 14:30 - Email from Client

   **Subject**: Project Update from Client
   **From**: [email protected]
   **Summary**: Client approved Phase 2 designs with minor revisions
   **File**: [View full communication](by-date/2025-12/2025-12-10_14-30_email_project-update.md)
   **Related**: Sprint 5, Beta Release Milestone
   ```

4. **Maintain chronological order**:
   - Insert new entry in correct position (sorted by timestamp)
   - Update surrounding entries if needed for context

5. **Cross-reference with existing communications**:
   - If part of email thread → Link to previous
   - If same topic as recent → Note relationship
   - If references project artifacts → Add links

### Phase 6: Save and Organize

**Objective**: Save communication to appropriate locations.

**Steps**:

1. **Determine file locations**:
   - Primary: `communications/by-date/YYYY-MM/filename.md`
   - Index reference: `communications/by-source/{source}/README.md`
   - Backup: `communications/raw/` (if configured)

2. **Create directory structure if needed**:
   ```bash
   mkdir -p communications/by-date/2025-12
   mkdir -p communications/by-source/email
   ```

3. **Save communication document**:
   ```bash
   Write communications/by-date/2025-12/2025-12-10_14-30_email_project-update.md
   ```

4. **Update by-source index**:
   Add to `communications/by-source/email/README.md`

5. **Verify save successful**:
   ```bash
   ls -la communications/by-date/2025-12/2025-12-10_14-30_email_project-update.md
   ```

### Phase 7: Governance Update

**Objective**: Update README.md indexes and project documentation.

**Steps**:

1. **Update communications/README.md**:
   ```markdown
   ## Recent Communications

   ### December 2025

   | Date | Type | Subject | From | File |
   |------|------|---------|------|------|
   | 2025-12-10 14:30 | Email | Project Update from Client | [email protected] | [View](by-date/2025-12/2025-12-10_14-30_email_project-update.md) |

   [Previous entries...]

   ---
   Last updated: 2025-12-10
   ```

2. **Update project root README.md**:
   Add to Recent Activity:
   ```markdown
   ## Recent Activity

   - 2025-12-10: Communication tracked - Client approval email for Phase 2
   ```

3. **Update related artifacts** (if applicable):
   - If communication mentions sprint → Update sprint document references
   - If communication contains decision → Create/update decision record
   - If communication has action items → Optionally create tasks

4. **Execute custom workflows from RULE.md**:
   Read and execute any project-specific workflows for communications.

### Phase 8: Report

**Objective**: Confirm completion and provide summary.

**Report format**:

```
Communication Tracked Successfully!

Type: [Email/Chat/Screenshot/Document]
Timestamp: YYYY-MM-DD HH:MM [confidence level]
From: [Sender]
Subject: [Topic]

Saved to:
- communications/by-date/YYYY-MM/filename.md
- Timeline updated (timeline.yaml, timeline.md)
[If backed up:]
- Original backed up: communications/raw/filename.ext

Related to:
- Sprint: [Sprint N or "None"]
- Milestone: [Milestone or "None"]
- Thread: [Previous communication or "New thread"]

Key Points Extracted:
- [Key point 1]
- [Key point 2]
- [Action items if any]

Governance Updated:
- communications/README.md
- Project README.md
[If linked to sprint/milestone:]
- sprints/sprint-N/sprint-plan.md

Tips:
- View timeline: "Show communication timeline"
- Search communications: "Find communications about [topic]"
- Track another: "Track this email: [content]"
```

## Special Cases

### Case 1: Batch Import

If user provides multiple communications at once:

```
User: "Import all these emails about the project"
[Multiple email contents or file paths]
```

**Process**:
1. Identify all items (emails/messages/files)
2. Process each individually (Phase 2-5)
3. Maintain thread relationships
4. Update timeline once with all entries
5. Report batch summary:
   ```
   Batch Import Complete!

   Imported 5 communications:
   - 3 emails (Dec 5, Dec 7, Dec 10)
   - 2 chat threads (Dec 6, Dec 9)

   Timeline updated with 5 new entries
   Thread relationships established

   [List of created files]
   ```

### Case 2: Thread/Conversation Tracking

If communication is part of ongoing thread:

**Process**:
1. Detect thread indicators (Re:, Fwd:, reply chains)
2. Search existing communications for thread
3. If found: Link as continuation
4. If not found: Ask if should create new thread
5. Update thread visualization in timeline:

```markdown
## Email Thread: Project Budget Discussion
├── 2025-12-05 09:00: Initial proposal [From: PM]
├── 2025-12-06 14:30: Questions from finance [From: CFO]
├── 2025-12-08 10:15: Revised proposal [From: PM]
└── 2025-12-10 16:00: Approval [From: CFO] ← NEW
```

### Case 3: Mixed Media Communication

If communication contains multiple media types:

```
User: "Track this email with the attached screenshot"
```

**Process**:
1. Process email content (Phase 2B)
2. Process attachment (Phase 2A for screenshot)
3. Create linked documents:
   - Main: email document
   - Attachment: screenshot analysis
4. Cross-reference in both documents
5. Single timeline entry with attachments noted

### Case 4: Urgent/Priority Communication

If communication marked as urgent or contains deadlines:

**Process**:
1. Detect urgency markers ("URGENT", "ASAP", deadline dates)
2. Add priority tag
3. Highlight in timeline with marker
4. Suggest linking to milestone/sprint if deadline related
5. Optionally: Create action item or reminder

**Timeline entry**:
```markdown
- [URGENT] [2025-12-10 14:30] Server maintenance window - Deadline Dec 12
```

### Case 5: Failed Timestamp Extraction

If cannot determine timestamp even after inferring:

**Process**:
1. Ask user directly for timestamp
2. If user doesn't know:
   - Offer to use "approximate" with date only
   - Offer to use current time with [estimated] marker
   - Let user specify "sometime in [week/month]"
3. Store with lowest confidence level
4. Mark in timeline as [Approximate Date]

### Case 6: Non-Project Communication

If user tracks communication not related to current project:

**Process**:
1. Detect if content relates to different project
2. Ask user to confirm:
   ```
   This communication appears to be about [other topic].
   Should I:
   1. Track it in this project anyway
   2. Track it to a different project (specify)
   3. Store it in a general communications archive
   ```

## Error Handling

### Error: Image cannot be read

```
Cannot analyze image at: [path]

Possible issues:
- File doesn't exist
- File format not supported
- File is corrupted

Solutions:
1. Check the file path and try again
2. Convert image to PNG/JPG format
3. Provide the content as text instead

Would you like to:
- Try a different file
- Enter the communication content manually
```

### Error: mu command not available

```
The `mu` email indexer is not available.

Options:
1. Paste email content directly (I'll parse it)
2. Provide email file path (.eml, .mbox)
3. Install mu: `brew install mu` (macOS) / `apt install maildir-utils` (Linux)

How would you like to proceed?
```

### Error: markitdown conversion failed

```
Could not convert file: [filename]

Error: [markitdown error message]

Options:
1. Try alternative conversion method
2. Extract text manually from file
3. Save original file without conversion
4. Skip this file

What would you like to do?
```

### Error: Timestamp conflict

```
Timestamp Conflict Detected

The timestamp extracted (2025-12-15 14:00) is in the future.
Current time is 2025-12-10 10:00.

Options:
1. Use extracted timestamp anyway (scheduled/future communication)
2. Correct to current date/time
3. Specify actual timestamp

Please clarify:
```

### Error: No RULE.md or communications/ directory

```
Project not initialized for communication tracking.

Options:
1. Initialize communications directory now (recommended)
2. Specify different target directory
3. Cancel

If you choose option 1, I'll ask a few configuration questions first.
```

### Error: Duplicate communication

```
Possible Duplicate Detected

A similar communication already exists:
- [existing file path]
- Date: [date]
- Subject: [subject]

Options:
1. Skip (don't create duplicate)
2. Create anyway (might be different)
3. Update existing entry instead
4. View existing entry first

What would you like to do?
```

## Integration with Other Skills

### With track-meeting Skill

If communication references a meeting:
- Detect meeting mentions ("discussed in meeting", meeting dates)
- Link to meeting notes if they exist
- Suggest creating meeting notes if referenced but not found

```yaml
related_meetings:
  - path: meetings/sprint-planning/2025-12-05_sprint-6-planning.md
    relationship: "discussed"
```

**In meeting documents, add Communications section**:
```markdown
## External Communications Referenced

Communications discussed or referenced in this meeting:
- [2025-12-04: Client Budget Approval](../../communications/by-date/2025-12/2025-12-04_email_budget-approval.md)
- [2025-12-03: Slack thread on API design](../../communications/by-date/2025-12/2025-12-03_screenshot_slack-api.md)
```

### With manage-sprint Skill

If communication mentions sprint work:
- Link to current sprint
- Extract mentioned user stories
- Update sprint document with external communication reference

```
Communication mentions: "User story 5 is blocked"
→ Link to sprint-06/sprint-plan.md
→ Add reference in sprint document's "Related Communications" section
```

**In sprint documents, add section**:
```markdown
## Related Communications

External communications related to this sprint:

### Client Feedback
- [2025-12-10: Phase 2 Approval](../../communications/by-date/2025-12/2025-12-10_14-30_email_project-update.md)

### Team Discussions
- [2025-12-07: Database Migration Decision](../../communications/by-date/2025-12/2025-12-07_09-00_screenshot_slack-db-migration.md)
```

### With track-milestone Skill

If communication updates milestone status:
- Link to relevant milestone
- Suggest milestone status update if communication indicates change
- Track milestone-related decisions

```
Communication says: "Client approved beta release"
→ Link to beta-release milestone
→ Suggest: "Should I update milestone status to 'approved'?"
```

**In milestones.yaml, reference key communications**:
```yaml
milestones:
  - id: beta-release
    name: "Beta Release"
    communications:
      - comm-a1b2c3d4  # Client approval
    approval_communication: comm-a1b2c3d4
```

### With project-search Skill

Communications are searchable:
- Full-text search in content
- Metadata search (from, to, date range)
- Tag-based search
- Timeline-based search

```
User: "Find communications from the client about budget"
→ Search communications with: from contains "client", content contains "budget"
→ Return timeline view of matching communications
```

**Search scope extension for project-search**:
- Include communications/ directory
- Search timeline.yaml for metadata matching
- Support filters: type:email, from:[sender], date:[range]

### With AkashicRecords Skills

If communications need to be stored in knowledge base:
- Use add-content for archival storage
- Cross-reference between communications/ and knowledge base
- Maintain links when content moves

## Best Practices

### 1. Always confirm timestamp

Timestamps are critical for timeline integrity. Never assume - always validate or ask when uncertain.

### 2. Extract key points automatically

Don't just store raw content. Extract actionable information (decisions, action items, deadlines).

### 3. Maintain thread relationships

Connect related communications. Conversations make more sense in context.

### 4. Link to project artifacts

Communications don't exist in isolation. Link to sprints, milestones, meetings.

### 5. Backup originals

Original data (especially screenshots) should be preserved for reference and compliance.

### 6. Use consistent naming

Follow filename conventions strictly: `YYYY-MM-DD_HH-MM_type_subject-slug.md`

### 7. Update timeline immediately

Don't batch timeline updates. Each communication should appear in timeline upon tracking.

### 8. Handle uncertainty gracefully

When information is unclear, ask rather than guess. User confirmation prevents errors.

### 9. Preserve original language

Keep content in its original language. Use English for structure (frontmatter, section headers).

### 10. Auto-detect but verify

Auto-detection is helpful but not perfect. Always show extracted information for user verification.

## Examples

### Example 1: Track Email

```
User: Track this email:
From: [email protected]
To: [email protected]
Date: Dec 10, 2025 2:30 PM
Subject: Re: Phase 2 Design Review

Hi,

We've reviewed the Phase 2 designs and they look great!
Please proceed with the following minor revisions:
1. Update the color scheme to match brand guidelines
2. Increase font size in the navigation menu
3. Add help text below the form fields

Deadline: Please complete by Dec 15.

Thanks,
Client

Claude: Tracking email communication...

Communication Tracked Successfully!

Type: Email
Timestamp: 2025-12-10 14:30 [exact]
From: [email protected]
Subject: Re: Phase 2 Design Review

Saved to:
- communications/by-date/2025-12/2025-12-10_14-30_email_phase-2-design-review.md
- Timeline updated

Key Points Extracted:
- Phase 2 designs approved
- 3 minor revisions requested:
  1. Color scheme update
  2. Navigation font size
  3. Form help text
- Deadline: Dec 15, 2025

Action Items Detected:
- [ ] Update color scheme to brand guidelines
- [ ] Increase navigation font size
- [ ] Add help text to form fields

Should I link this to a sprint or milestone?
```

### Example 2: Track Screenshot

```
User: Import this Slack screenshot: /tmp/slack-conversation.png

Claude: Analyzing screenshot...

Screenshot Analysis Complete

Source: Slack (#engineering channel)
Date: [Cannot determine from image - when was this conversation?]

Participants:
- @alice
- @bob
- @carol

Content Summary:
Discussion about database migration strategy.
Alice proposed PostgreSQL, Bob agreed, Carol raised concerns about timeline.
Decision: Proceed with PostgreSQL, migration window Dec 20-22.

User: It was from yesterday around 9am

Claude: Got it!

Communication Tracked Successfully!

Type: Screenshot (Slack)
Timestamp: 2025-12-09 09:00 [inferred]
From: @alice (initiator)
Channel: #engineering
Subject: Database Migration Discussion

Saved to:
- communications/by-date/2025-12/2025-12-09_09-00_screenshot_slack-db-migration.md
- Original backed up: communications/raw/2025-12-09_slack-conversation.png

Key Points:
- PostgreSQL migration approved
- Migration window: Dec 20-22
- Timeline concerns noted (from Carol)

Decision Recorded:
"Proceed with PostgreSQL migration during Dec 20-22 window"

Timeline and governance updated.
```

### Example 3: Batch Import

```
User: I have 3 emails about the project from last week, import them all
[Provides 3 email contents]

Claude: Processing batch import...

Processing email 1/3: Budget Approval (Dec 5)...
Processing email 2/3: Technical Review (Dec 6)...
Processing email 3/3: Timeline Update (Dec 7)...

Batch Import Complete!

Imported 3 communications:
- 2025-12-05: Budget Approval [from: [email protected]]
- 2025-12-06: Technical Review [from: [email protected]]
- 2025-12-07: Timeline Update [from: [email protected]]

Thread Analysis:
- These appear to be related to the same project review
- Linked as conversation thread: "Project Review December"

Files created:
- communications/by-date/2025-12/2025-12-05_10-00_email_budget-approval.md
- communications/by-date/2025-12/2025-12-06_14-30_email_technical-review.md
- communications/by-date/2025-12/2025-12-07_09-15_email_timeline-update.md

Timeline updated with 3 new entries.
All communications linked to Sprint 5.
```

### Example 4: First-Time Setup

```
User: Track this email from my client

Claude: I notice this is the first time using communication tracking.
Let me set up the communications directory first.

Timeline Configuration
Should I create a dedicated timeline tracking file?

User: Yes, both formats

Claude: Original Data Backup
Should I backup original source data?

User: Yes, always backup

Claude: Communication Sources
What types of communications do you typically track?

User: Email and screenshots mainly

Claude: Timestamp Handling
How should I handle communications without clear timestamps?

User: Try to figure it out, ask me if unsure

Claude:
Communication Tracker Configured!

Structure created:
communications/
├── config.yaml
├── README.md
├── timeline.yaml
├── timeline.md
├── raw/
├── by-source/
└── by-date/

Now tracking your email...

[Proceeds to track the email]
```

## Notes

- Communication tracking adds external context to project timeline
- Timeline is the source of truth for chronological project history
- Screenshots require Claude's vision capability for analysis
- Email integration via `mu` is optional - direct text input always works
- Thread tracking maintains conversation continuity across multiple communications
- Backup strategy should align with project/organization compliance requirements
- This Skill complements track-meeting by handling async communications
- Content language is preserved; structure uses English for consistency
- Timestamp confidence is always tracked to maintain timeline integrity

---

Effective communication tracking transforms scattered emails and messages into coherent project history. This Skill bridges the gap between external communications and internal project management.