feat: add Chiron agent framework with 6 agents and 5 integration skills

Complete implementation of personal productivity agent framework for Oh-My-Opencode.

## Components Added

### Agents (6 total)
- Primary agents: chiron (Plan Mode), chiron-forge (Build Mode)
- Subagents: hermes (work communication), athena (work knowledge), apollo (private knowledge), calliope (writing)

### System Prompts (6 total)
- prompts/chiron.txt - Main orchestrator with delegation logic
- prompts/chiron-forge.txt - Execution/build counterpart
- prompts/hermes.txt - Basecamp, Outlook, MS Teams specialist
- prompts/athena.txt - Outline wiki/documentation specialist
- prompts/apollo.txt - Obsidian vault/private notes specialist
- prompts/calliope.txt - Writing/documentation specialist

### Integration Skills (5 total)
- skills/basecamp/SKILL.md - 63 MCP tools documented
- skills/outline/SKILL.md - Wiki/document management
- skills/msteams/SKILL.md - Teams/channels/meetings
- skills/outlook/SKILL.md - Email/calendar/contacts
- skills/obsidian/SKILL.md - Vault/note management

### Validation
- scripts/validate-agents.sh - Agent configuration validation
- All agents validated: JSON structure, modes, prompt references
- All prompts verified: Exist, non-empty, >500 chars
- All skills verified: Valid YAML frontmatter, SKILL.md structure

## Verification
 6 agents in agents.json
 All 6 prompt files exist and non-empty
 All 5 skills have valid SKILL.md with YAML frontmatter
 validate-agents.sh passes (exit 0)

Co-authored-by: Sisyphus framework <atlas@opencode.dev>
This commit is contained in:
m3tm3re
2026-02-03 20:30:34 +01:00
parent 76cd0e4ee6
commit 1e7decc84a
11 changed files with 2957 additions and 127 deletions

315
skills/basecamp/SKILL.md Normal file
View File

@@ -0,0 +1,315 @@
---
name: basecamp
description: "Use when: (1) Managing Basecamp projects, (2) Working with Basecamp todos and tasks, (3) Reading/updating message boards and campfire, (4) Managing card tables (kanban), (5) Handling email forwards/inbox, (6) Setting up webhooks for automation. Triggers: 'Basecamp', 'project', 'todo', 'card table', 'campfire', 'message board', 'webhook', 'inbox', 'email forwards'."
compatibility: opencode
---
# Basecamp
Basecamp 3 project management integration via MCP server. Provides comprehensive access to projects, todos, messages, card tables (kanban), campfire, inbox, documents, and webhooks.
## Core Workflows
### Finding Projects and Todos
**List all projects:**
```bash
# Get all accessible Basecamp projects
get_projects
```
**Get project details:**
```bash
# Get specific project information including status, tools, and access level
get_project --project_id <id>
```
**Explore todos:**
```bash
# Get all todo lists in a project
get_todolists --project_id <id>
# Get all todos from a specific todo list (handles pagination automatically)
get_todos --recording_id <todo_list_id>
# Search across projects for todos/messages containing keywords
search_basecamp --query <search_term>
```
### Managing Card Tables (Kanban)
**Card tables** are Basecamp's kanban-style workflow management tool.
**Explore card table:**
```bash
# Get card table for a project
get_card_table --project_id <id>
# Get all columns in a card table
get_columns --card_table_id <id>
# Get all cards in a specific column
get_cards --column_id <id>
```
**Manage columns:**
```bash
# Create new column (e.g., "In Progress", "Done")
create_column --card_table_id <id> --title "Column Name"
# Update column title
update_column --column_id <id> --title "New Title"
# Move column to different position
move_column --column_id <id> --position 3
# Update column color
update_column_color --column_id <id> --color "red"
# Put column on hold (freeze work)
put_column_on_hold --column_id <id>
# Remove hold from column (unfreeze work)
remove_column_hold --column_id <id>
```
**Manage cards:**
```bash
# Create new card in a column
create_card --column_id <id> --title "Task Name" --content "Description"
# Update card details
update_card --card_id <id> --title "Updated Title" --content "New content"
# Move card to different column
move_card --card_id <id> --to_column_id <new_column_id>
# Mark card as complete
complete_card --card_id <id>
# Mark card as incomplete
uncomplete_card --card_id <id>
```
**Manage card steps (sub-tasks):**
```bash
# Get all steps for a card
get_card_steps --card_id <id>
# Create new step
create_card_step --card_id <id> --content "Sub-task description"
# Update step
update_card_step --step_id <id> --content "Updated description"
# Delete step
delete_card_step --step_id <id>
# Mark step as complete
complete_card_step --step_id <id>
# Mark step as incomplete
uncomplete_card_step --step_id <id>
```
### Working with Messages and Campfire
**Message board:**
```bash
# Get message board for a project
get_message_board --project_id <id>
# Get all messages from a project
get_messages --project_id <id>
# Get specific message
get_message --message_id <id>
```
**Campfire (team chat):**
```bash
# Get recent campfire lines (messages)
get_campfire_lines --campfire_id <id>
```
**Comments:**
```bash
# Get comments for any Basecamp item (message, todo, card, etc.)
get_comments --recording_id <id>
# Create a comment
create_comment --recording_id <id> --content "Your comment"
```
### Managing Inbox (Email Forwards)
**Inbox** handles email forwarding to Basecamp projects.
**Explore inbox:**
```bash
# Get inbox for a project (email forwards container)
get_inbox --project_id <id>
# Get all forwarded emails from a project's inbox
get_forwards --project_id <id>
# Get specific forwarded email
get_forward --forward_id <id>
# Get all replies to a forwarded email
get_inbox_replies --forward_id <id>
# Get specific reply
get_inbox_reply --reply_id <id>
```
**Manage forwards:**
```bash
# Move forwarded email to trash
trash_forward --forward_id <id>
```
### Documents
**Manage documents:**
```bash
# List documents in a vault
get_documents --vault_id <id>
# Get specific document
get_document --document_id <id>
# Create new document
create_document --vault_id <id> --title "Document Title" --content "Document content"
# Update document
update_document --document_id <id> --title "Updated Title" --content "New content"
# Move document to trash
trash_document --document_id <id>
```
### Webhooks and Automation
**Webhooks** enable automation by triggering external services on Basecamp events.
**Manage webhooks:**
```bash
# List webhooks for a project
get_webhooks --project_id <id>
# Create webhook
create_webhook --project_id <id> --callback_url "https://your-service.com/webhook" --types "TodoCreated,TodoCompleted"
# Delete webhook
delete_webhook --webhook_id <id>
```
### Daily Check-ins
**Project check-ins:**
```bash
# Get daily check-in questions for a project
get_daily_check_ins --project_id <id>
# Get answers to daily check-in questions
get_question_answers --question_id <id>
```
### Attachments and Events
**Upload and track:**
```bash
# Upload file as attachment
create_attachment --recording_id <id> --file_path "/path/to/file"
# Get events for a recording
get_events --recording_id <id>
```
## Integration with Other Skills
### Hermes (Work Communication)
Hermes loads this skill when working with Basecamp projects. Common workflows:
| User Request | Hermes Action | Basecamp Tools Used |
|--------------|---------------|---------------------|
| "Create a task in Marketing project" | Create card/todo | `create_card`, `get_columns`, `create_column` |
| "Check project updates" | Read messages/campfire | `get_messages`, `get_campfire_lines`, `get_comments` |
| "Update my tasks" | Move cards, update status | `move_card`, `complete_card`, `update_card` |
| "Add comment to discussion" | Post comment | `create_comment`, `get_comments` |
| "Review project inbox" | Check email forwards | `get_inbox`, `get_forwards`, `get_inbox_replies` |
### Workflow Patterns
**Project setup:**
1. Use `get_projects` to find existing projects
2. Use `get_project` to verify project details
3. Use `get_todolists` or `get_card_table` to understand project structure
**Task management:**
1. Use `get_todolists` or `get_columns` to find appropriate location
2. Use `create_card` or todo creation to add work
3. Use `move_card`, `complete_card` to update status
4. Use `get_card_steps` and `create_card_step` for sub-task breakdown
**Communication:**
1. Use `get_messages` or `get_campfire_lines` to read discussions
2. Use `create_comment` to contribute to existing items
3. Use `search_basecamp` to find relevant content
**Automation:**
1. Use `get_webhooks` to check existing integrations
2. Use `create_webhook` to set up external notifications
## Tool Organization by Category
**Projects & Lists:**
- `get_projects`, `get_project`, `get_todolists`, `get_todos`, `search_basecamp`
**Card Table (Kanban):**
- `get_card_table`, `get_columns`, `get_column`, `create_column`, `update_column`, `move_column`, `update_column_color`, `put_column_on_hold`, `remove_column_hold`, `watch_column`, `unwatch_column`, `get_cards`, `get_card`, `create_card`, `update_card`, `move_card`, `complete_card`, `uncomplete_card`, `get_card_steps`, `create_card_step`, `get_card_step`, `update_card_step`, `delete_card_step`, `complete_card_step`, `uncomplete_card_step`
**Messages & Communication:**
- `get_message_board`, `get_messages`, `get_message`, `get_campfire_lines`, `get_comments`, `create_comment`
**Inbox (Email Forwards):**
- `get_inbox`, `get_forwards`, `get_forward`, `get_inbox_replies`, `get_inbox_reply`, `trash_forward`
**Documents:**
- `get_documents`, `get_document`, `create_document`, `update_document`, `trash_document`
**Webhooks:**
- `get_webhooks`, `create_webhook`, `delete_webhook`
**Other:**
- `get_daily_check_ins`, `get_question_answers`, `create_attachment`, `get_events`
## Common Queries
**Finding the right project:**
```bash
# Use search to find projects by keyword
search_basecamp --query "marketing"
# Then inspect specific project
get_project --project_id <id>
```
**Understanding project structure:**
```bash
# Check which tools are available in a project
get_project --project_id <id>
# Project response includes tools: message_board, campfire, card_table, todolists, etc.
```
**Bulk operations:**
```bash
# Get all todos across a project (pagination handled automatically)
get_todos --recording_id <todo_list_id>
# Returns all pages of results
# Get all cards across all columns
get_columns --card_table_id <id>
get_cards --column_id <id> # Repeat for each column
```

108
skills/msteams/SKILL.md Normal file
View File

@@ -0,0 +1,108 @@
---
name: msteams
description: "Microsoft Teams Graph API integration for team communication. Use when: (1) Managing teams and channels, (2) Sending/receiving channel messages, (3) Scheduling or managing meetings, (4) Handling chat conversations. Triggers: 'Teams', 'meeting', 'channel', 'team message', 'chat', 'Teams message'."
compatibility: opencode
---
# Microsoft Teams Integration
Microsoft Teams Graph API integration for managing team communication, channels, messages, meetings, and chat conversations via MCP tools.
## Core Capabilities
### Teams & Channels
- **List joined teams**: Retrieve all teams the user is a member of
- **Manage channels**: Create, list, and manage channels within teams
- **Team membership**: Add, remove, and update team members
### Channel Messages
- **Send messages**: Post messages to channels with rich text support
- **Retrieve messages**: List channel messages with filtering by date range
- **Message management**: Read and respond to channel communications
### Online Meetings
- **Schedule meetings**: Create online meetings with participants
- **Manage meetings**: Update meeting details and coordinates
- **Meeting access**: Retrieve join links and meeting information
- **Presence**: Check user presence and activity status
### Chat
- **Direct messages**: 1:1 chat conversations with users
- **Group chats**: Multi-person chat conversations
- **Chat messages**: Send and receive chat messages
## Common Workflows
### Send Channel Message
1. Identify target team and channel
2. Compose message content
3. Use MCP tool to send message to channel
Example:
```
"Post a message to the 'General' channel in 'Engineering' team about the deployment status"
```
### Schedule Meeting
1. Determine meeting participants
2. Set meeting time and duration
3. Create meeting title and description
4. Use MCP tool to create online meeting
Example:
```
"Schedule a meeting with @alice and @bob for Friday 2pm to discuss the project roadmap"
```
### List Channel Messages
1. Specify team and channel
2. Define date range (required for polling)
3. Retrieve and display messages
Example:
```
"Show me all messages in #general from the last week"
```
### Send Direct Message
1. Identify recipient user
2. Compose message
3. Use MCP chat tool to send message
Example:
```
"Send a message to @john asking if the PR review is complete"
```
## MCP Tool Categories
The MS Teams MCP server provides tool categories for:
- **Channels**: Team and channel management operations
- **Messages**: Channel message operations
- **Meetings**: Online meeting scheduling and management
- **Chat**: Direct and group chat operations
## Important Constraints
**Authentication**: Do NOT include Graph API authentication flows. The MCP server handles authentication configuration.
**Polling limits**: When retrieving messages, always specify a date range. Polling the same resource more than once per day is a violation of Microsoft APIs Terms of Use.
**Email overlap**: Do NOT overlap with Outlook email functionality. This skill focuses on Teams-specific communication (channels, chat, meetings), not email operations.
**File storage**: Files in channels are stored in SharePoint. Use SharePoint-specific operations for file management.
## Domain Boundaries
This skill integrates with **Hermes** (work communication agent). Hermes loads this skill when user requests:
- Teams-related operations
- Meeting scheduling or management
- Channel communication
- Teams chat conversations
For email operations, Hermes uses the **outlook** skill instead.

240
skills/obsidian/SKILL.md Normal file
View File

@@ -0,0 +1,240 @@
---
name: obsidian
description: "Obsidian Local REST API integration for knowledge management. Use when: (1) Creating, reading, updating, or deleting notes in Obsidian vault, (2) Searching vault content by title, content, or tags, (3) Managing daily notes and journaling, (4) Working with WikiLinks and vault metadata. Triggers: 'Obsidian', 'note', 'vault', 'WikiLink', 'daily note', 'journal', 'create note'."
compatibility: opencode
---
# Obsidian
Knowledge management integration via Obsidian Local REST API for vault operations, note CRUD, search, and daily notes.
## Prerequisites
- **Obsidian Local REST API plugin** installed and enabled in Obsidian
- **API server running** on default port `27124` (or configured custom port)
- **Vault path** configured in plugin settings
- **API key** set (optional, if authentication enabled)
API endpoints available at `http://127.0.0.1:27124` by default.
## Core Workflows
### List Vault Files
Get list of all files in vault:
```bash
curl -X GET "http://127.0.0.1:27124/list"
```
Returns array of file objects with `path`, `mtime`, `ctime`, `size`.
### Get File Metadata
Retrieve metadata for a specific file:
```bash
curl -X GET "http://127.0.0.1:27124/get-file-info?path=Note%20Title.md"
```
Returns file metadata including tags, links, frontmatter.
### Create Note
Create a new note in the vault:
```bash
curl -X POST "http://127.0.0.1:27124/create-note" \
-H "Content-Type: application/json" \
-d '{"content": "# Note Title\n\nNote content..."}'
```
Use `path` parameter for specific location:
```json
{
"content": "# Note Title\n\nNote content...",
"path": "subdirectory/Note Title.md"
}
```
### Read Note
Read note content by path:
```bash
curl -X GET "http://127.0.0.1:27124/read-note?path=Note%20Title.md"
```
Returns note content as plain text or structured JSON with frontmatter parsing.
### Update Note
Modify existing note:
```bash
curl -X PUT "http://127.0.0.1:27124/update-note" \
-H "Content-Type: application/json" \
-d '{"path": "Note Title.md", "content": "# Updated Title\n\nNew content..."}'
```
### Delete Note
Remove note from vault:
```bash
curl -X DELETE "http://127.0.0.1:27124/delete-note?path=Note%20Title.md"
```
**Warning**: This operation is irreversible. Confirm with user before executing.
### Search Notes
Find notes by content, title, or tags:
```bash
# Content search
curl -X GET "http://127.0.0.1:27124/search?q=search%20term"
# Search with parameters
curl -X GET "http://127.0.0.1:27124/search?q=search%20term&path=subdirectory&context-length=100"
```
Returns array of matches with file path and context snippets.
### Daily Notes
#### Get Daily Note
Retrieve or create daily note for specific date:
```bash
# Today
curl -X GET "http://127.0.0.1:27124/daily-note"
# Specific date (YYYY-MM-DD)
curl -X GET "http://127.0.0.1:27124/daily-note?date=2026-02-03"
```
Returns daily note content or creates using Obsidian's Daily Notes template.
#### Update Daily Note
Modify today's daily note:
```bash
curl -X PUT "http://127.0.0.1:27124/daily-note" \
-H "Content-Type: application/json" \
-d '{"content": "## Journal\n\nToday I learned..."}'
```
### Get Vault Info
Retrieve vault metadata:
```bash
curl -X GET "http://127.0.0.1:27124/vault-info"
```
Returns vault path, file count, and configuration details.
## Note Structure Patterns
### Frontmatter Conventions
Use consistent frontmatter for note types:
```yaml
---
date: 2026-02-03
created: 2026-02-03T10:30:00Z
type: note
tags: #tag1 #tag2
status: active
---
```
### WikiLinks
Reference other notes using Obsidian WikiLinks:
- `[[Note Title]]` - Link to note by title
- `[[Note Title|Alias]]` - Link with custom display text
- `[[Note Title#Heading]]` - Link to specific heading
- `![[Image.png]]` - Embed images or media
### Tagging
Use tags for categorization:
- `#tag` - Single-word tag
- `#nested/tag` - Hierarchical tags
- Tags in frontmatter for metadata
- Tags in content for inline categorization
## Workflow Examples
### Create Brainstorm Note
```bash
curl -X POST "http://127.0.0.1:27124/create-note" \
-H "Content-Type: application/json" \
-d '{
"path": "03-resources/brainstorms/2026-02-03-Topic.md",
"content": "---\ndate: 2026-02-03\ncreated: 2026-02-03T10:30:00Z\ntype: brainstorm\nframework: pros-cons\nstatus: draft\ntags: #brainstorm #pros-cons\n---\n\n# Topic\n\n## Context\n\n## Options\n\n## Decision\n"
}'
```
### Append to Daily Journal
```bash
# Get current daily note
NOTE=$(curl -s "http://127.0.0.1:27124/daily-note")
# Append content
curl -X PUT "http://127.0.0.1:27124/daily-note" \
-H "Content-Type: application/json" \
-d "{\"content\": \"${NOTE}\n\n## Journal Entry\n\nLearned about Obsidian API integration.\"}"
```
### Search and Link Notes
```bash
# Search for related notes
curl -s "http://127.0.0.1:27124/search?q=Obsidian"
# Create note with WikiLinks to found notes
curl -X POST "http://127.0.0.1:27124/create-note" \
-H "Content-Type: application/json" \
-d '{
"path": "02-areas/Obsidian API Guide.md",
"content": "# Obsidian API Guide\n\nSee [[API Endpoints]] and [[Workflows]] for details."
}'
```
## Integration with Other Skills
| From Obsidian | To skill | Handoff pattern |
|--------------|----------|----------------|
| Note created | brainstorming | Create brainstorm note with frontmatter |
| Daily note updated | reflection | Append conversation analysis to journal |
| Research note | research | Save research findings with tags |
| Project note | task-management | Link tasks to project notes |
| Plan document | plan-writing | Save generated plan to vault |
## Best Practices
1. **Use paths consistently** - Follow PARA structure or vault conventions
2. **Include frontmatter** - Enables search and metadata queries
3. **Use WikiLinks** - Creates knowledge graph connections
4. **Validate paths** - Check file existence before operations
5. **Handle errors** - API may return 404 for non-existent files
6. **Escape special characters** - URL-encode paths with spaces or symbols
7. **Backup vault** - REST API operations modify files directly
## Error Handling
Common HTTP status codes:
- `200 OK` - Success
- `404 Not Found` - File or resource doesn't exist
- `400 Bad Request` - Invalid parameters or malformed JSON
- `500 Internal Server Error` - Plugin or vault error
Check API response body for error details before retrying operations.

126
skills/outline/SKILL.md Normal file
View File

@@ -0,0 +1,126 @@
---
name: outline
description: "Outline wiki integration for knowledge management and documentation workflows. Use when Opencode needs to interact with Outline for: (1) Creating and editing documents, (2) Searching and retrieving knowledge base content, (3) Managing document collections and hierarchies, (4) Handling document sharing and permissions, (5) Collaborative features like comments. Triggers: 'Outline', 'wiki', 'knowledge base', 'documentation', 'team docs', 'document in Outline', 'search Outline', 'Outline collection'."
compatibility: opencode
---
# Outline Wiki Integration
Outline is a team knowledge base and wiki platform. This skill provides guidance for Outline API operations and knowledge management workflows.
## Core Capabilities
### Document Operations
- **Create**: Create new documents with markdown content
- **Read**: Retrieve document content, metadata, and revisions
- **Update**: Edit existing documents, update titles and content
- **Delete**: Remove documents (with appropriate permissions)
### Collection Management
- **Organize**: Structure documents in collections and nested collections
- **Hierarchies**: Create parent-child relationships
- **Access Control**: Set permissions at collection level
### Search and Discovery
- **Full-text search**: Find documents by content
- **Metadata filters**: Search by collection, author, date
- **Advanced queries**: Combine multiple filters
### Sharing and Permissions
- **Public links**: Generate shareable document URLs
- **Team access**: Manage member permissions
- **Guest access**: Control external sharing
### Collaboration
- **Comments**: Add threaded discussions to documents
- **Revisions**: Track document history and changes
- **Notifications**: Stay updated on document activity
## Workflows
### Creating a New Document
1. Determine target collection
2. Create document with title and initial content
3. Set appropriate permissions
4. Share with relevant team members if needed
### Searching Knowledge Base
1. Formulate search query
2. Apply relevant filters (collection, date, author)
3. Review search results
4. Retrieve full document content when needed
### Organizing Documents
1. Review existing collection structure
2. Identify appropriate parent collection
3. Create or update documents in hierarchy
4. Update collection metadata if needed
### Document Collaboration
1. Add comments for feedback or discussion
2. Track revision history for changes
3. Notify stakeholders when needed
4. Resolve comments when addressed
## Integration Patterns
### Knowledge Capture
When capturing information from conversations or research:
- Create document in appropriate collection
- Use clear, descriptive titles
- Structure content with headers for readability
- Add tags for discoverability
### Documentation Updates
When updating existing documentation:
- Retrieve current document revision
- Make targeted, minimal changes
- Add comments explaining significant updates
- Share updates with relevant stakeholders
### Knowledge Retrieval
When searching for information:
- Start with broad search terms
- Refine with collection and metadata filters
- Review multiple relevant documents
- Cross-reference linked documents for context
## Common Use Cases
| Use Case | Recommended Approach |
|----------|---------------------|
| Project documentation | Create collection per project, organize by phase |
| Team guidelines | Use dedicated collection, group by topic |
| Meeting notes | Create documents with templates, tag by team |
| Knowledge capture | Search before creating, link to related docs |
| Onboarding resources | Create structured collection with step-by-step guides |
## Best Practices
- **Consistent naming**: Use clear, descriptive titles
- **Logical organization**: Group related documents in collections
- **Regular maintenance**: Review and update outdated content
- **Access control**: Set appropriate permissions for sensitive content
- **Searchability**: Use tags and metadata effectively
- **Collaboration**: Use comments for discussions, not content changes
## Handoff to Other Skills
| Output | Next Skill | Trigger |
|--------|------------|---------|
| Research findings | knowledge-management | "Organize this research in Outline" |
| Documentation draft | communications | "Share this document via email" |
| Task from document | task-management | "Create tasks from this outline" |
| Project plan | plan-writing | "Create project plan in Outline" |

231
skills/outlook/SKILL.md Normal file
View File

@@ -0,0 +1,231 @@
---
name: outlook
description: "Outlook Graph API integration for email, calendar, and contact management. Use when: (1) Reading or sending emails, (2) Managing inbox and folders, (3) Working with calendar events and appointments, (4) Managing contacts, (5) Organizing email messages. Triggers: 'email', 'Outlook', 'inbox', 'calendar', 'contact', 'message', 'folder', 'appointment', 'meeting'."
compatibility: opencode
---
# Outlook
Outlook Graph API integration for mail, calendar, and contact management via MCP. Enables comprehensive email workflows, calendar coordination, and contact organization.
## Overview
Outlook is Microsoft 365's messaging and communication hub. This skill provides access to:
- **Mail**: Send, receive, search, organize, and categorize messages
- **Calendar**: Create and manage events, appointments, and meetings
- **Contacts**: Manage contact information and relationships
- **Folders**: Organize messages into custom folder structures
## Core Workflows
### 1. Reading Emails
Retrieve messages from mailbox:
```
User: "Check my inbox for new messages from John"
AI: Use Outlook MCP to:
1. List messages in Inbox folder
2. Filter by sender = "John"
3. Display summary (subject, date, importance)
```
**Use search and sort** to efficiently find messages:
- Filter by folder (Inbox, Sent, Drafts, etc.)
- Sort by date, importance, or subject
- Search by sender, subject, or content
### 2. Sending Emails
Compose and send new messages:
```
User: "Send an email to sarah@company.com about the project update"
AI: Use Outlook MCP to:
1. Create message draft with recipient and subject
2. Add body content
3. Send the message
```
**Key options**:
- Add attachments
- Set importance (low, normal, high)
- Add recipients (to, cc, bcc)
- Use categories for organization
### 3. Replying and Forwarding
Respond to existing messages:
```
User: "Reply to the last email from Mike with thanks"
AI: Use Outlook MCP to:
1. Retrieve the most recent message from Mike
2. Create reply with appropriate body
3. Send the reply
```
**Supports**:
- Reply (to sender)
- Reply All (to all recipients)
- Forward (to new recipients)
### 4. Managing Folders
Organize messages into folder structure:
```
User: "Move all emails from vendor@supplier.com to Vendors folder"
AI: Use Outlook MCP to:
1. Search for messages from vendor@supplier.com
2. Move matching messages to Vendors folder
3. Confirm move operation
```
**Folder operations**:
- List folders
- Create new folders
- Move messages between folders
- Delete folders (careful!)
### 5. Calendar Events
Manage calendar and schedule meetings:
```
User: "Schedule a team meeting for Friday at 2pm"
AI: Use Outlook MCP to:
1. Create calendar event
2. Set date/time (Friday 2:00 PM)
3. Add attendees
4. Send meeting invitation
```
**Event details**:
- Subject and location
- Start/end times
- Attendees and required/optional status
- Meeting body/agenda
- Recurrence (for recurring meetings)
### 6. Managing Contacts
Create and maintain contact information:
```
User: "Add Jane Smith to contacts: jane@company.com, 555-1234"
AI: Use Outlook MCP to:
1. Create contact object
2. Add email address and phone number
3. Save to contacts
```
**Contact fields**:
- Name (first, last, display name)
- Email addresses (multiple)
- Phone numbers (multiple types)
- Company, job title
- Notes
## Advanced Features
### Message Organization
**Categories**: Tag messages with color-coded categories for enhanced organization
```
User: "Tag these project emails as 'Urgent' category"
AI: Use Outlook MCP to:
1. Retrieve specified messages
2. Assign category (e.g., "Urgent")
3. Confirm categorization
```
**Importance**: Mark messages as high, normal, or low importance
```
User: "Mark this message as high priority"
AI: Use Outlook MCP to update message importance flag
```
**Search**: Find messages by sender, subject, content, or date range
```
User: "Find all emails about Q4 budget from October"
AI: Use Outlook MCP to search with filters:
- Subject contains "budget"
- Date range: October
- Optionally filter by sender
```
### Email Intelligence
**Focused Inbox**: Access messages categorized as focused vs other
**Mail Tips**: Check recipient status before sending (auto-reply, full mailbox)
**MIME Support**: Handle email in MIME format for interoperability
## Integration with Other Skills
This skill focuses on Outlook-specific operations. For related functionality:
| Need | Skill | When to Use |
|------|-------|-------------|
| **Team project updates** | basecamp | "Update the Basecamp todo" |
| **Team channel messages** | msteams | "Post this in the Teams channel" |
| **Private notes about emails** | obsidian | "Save this to Obsidian" |
| **Drafting long-form emails** | calliope | "Help me write a professional email" |
| **Short quick messages** | hermes (this skill) | "Send a quick update" |
## Common Patterns
### Email Triage Workflow
1. **Scan inbox**: List messages sorted by date
2. **Categorize**: Assign categories based on content/urgency
3. **Action**: Reply, forward, or move to appropriate folder
4. **Track**: Flag for follow-up if needed
### Meeting Coordination
1. **Check availability**: Query calendar for conflicts
2. **Propose time**: Suggest multiple time options
3. **Create event**: Set up meeting with attendees
4. **Follow up**: Send reminder or agenda
### Project Communication
1. **Search thread**: Find all messages related to project
2. **Organize**: Move to project folder
3. **Categorize**: Tag with project category
4. **Summarize**: Extract key points if needed
## Quality Standards
- **Accurate recipient addressing**: Verify email addresses before sending
- **Clear subject lines**: Ensure subjects accurately reflect content
- **Appropriate categorization**: Use categories consistently
- **Folder hygiene**: Maintain organized folder structure
- **Respect privacy**: Do not share sensitive content indiscriminately
## Edge Cases
**Multiple mailboxes**: This skill supports primary and shared mailboxes, not archive mailboxes
**Large attachments**: Use appropriate attachment handling for large files
**Meeting conflicts**: Check calendar availability before scheduling
**Email limits**: Respect rate limits and sending quotas
**Deleted items**: Use caution with delete operations (consider archiving instead)
## Boundaries
- **Do NOT handle Teams-specific messaging** (Teams's domain)
- **Do NOT handle Basecamp communication** (basecamp's domain)
- **Do NOT manage wiki documentation** (Athena's domain)
- **Do NOT access private Obsidian vaults** (Apollo's domain)
- **Do NOT write creative email content** (delegate to calliope for drafts)