diff --git a/.github/workflows/proxmox-deployment.yml b/.github/workflows/proxmox-deployment.yml
new file mode 100644
index 0000000..adcb19c
--- /dev/null
+++ b/.github/workflows/proxmox-deployment.yml
@@ -0,0 +1,38 @@
+name: Proxmox Deployment
+
+on: 
+    push:
+    create:
+    delete:
+  
+jobs:
+    setup-runner:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Install dependencies
+              run: |
+                sudo apt-get update
+                sudo apt install -y sshpass jq
+            - name: Setting up runner
+              uses: maxklema/proxmox-launchpad@main
+              with:
+                proxmox_username: ${{ secrets.PROXMOX_USERNAME }}
+                proxmox_password: ${{ secrets.PROXMOX_PASSWORD }}
+                github_pat: ${{ secrets.RUNNER_PAT }}
+    deploy:
+        runs-on: self-hosted
+        needs: setup-runner
+        steps:
+          - name: Deploy to Proxmox
+            uses: maxklema/proxmox-launchpad@main
+            with: 
+                proxmox_username: ${{ secrets.PROXMOX_USERNAME }}
+                proxmox_password: ${{ secrets.PROXMOX_PASSWORD }}
+                public_key: ${{ secrets.PUBLIC_KEY }}
+                http_port: 3000
+                install_command: npm install
+                start_command: meteor run --port 0.0.0.0:3000 --allow-superuser
+                runtime_language: nodejs
+                services: '["meteor"]'
+
+                
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 12ac647..85e62b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,6 @@
 node_modules/
-.DS_Store
\ No newline at end of file
+.DS_Store
+
+# Settings files (keep example, ignore actual settings)
+settings.json
+settings-local.json
\ No newline at end of file
diff --git a/.meteor/packages b/.meteor/packages
index 044a30e..6e10e98 100644
--- a/.meteor/packages
+++ b/.meteor/packages
@@ -25,3 +25,4 @@ hot-module-replacement@0.5.4  # Update code in development without reloading the
 blaze-hot               # Update files using Blaze's API with HMR
 accounts-base
 accounts-password
+webapp                  # HTTP server for webhooks and OAuth callbacks
diff --git a/README.md b/README.md
index e7fba3d..019d02a 100644
--- a/README.md
+++ b/README.md
@@ -43,10 +43,11 @@ Quick start: [click here](./HOW_TO_USE.md)
 1. **Clock In/Clock Out:** Simple, intuitive interface for starting and ending work or project sessions
 2. **Project & Objective Allocation:** Tag time entries to specific projects, objectives, or tasks (e.g., "robotics build," "grant writing," "classwork")
 3. **Personal Reflection & Notes:** Add context, challenges, and accomplishments to each time entry, helping communicate value and obstacles
-4. **User-Controlled Sharing:** All data remains private by default. Share with others (leaders, sponsors, teachers) only with explicit approval
-5. **Role Flexibility:** Designed for employees, students, mentors, volunteers, and nonprofit contributors
-6. **Reporting & Summaries:** Generate reports or summaries to share contributions, progress, or challenges as needed
-7. **Coach/Assistant Persona:** Supportive tool that helps with personal growth and positive communication
+4. **Calendar Integration:** Connect Google Calendar or Microsoft Outlook to automatically suggest time entries based on your meetings and appointments
+5. **User-Controlled Sharing:** All data remains private by default. Share with others (leaders, sponsors, teachers) only with explicit approval
+6. **Role Flexibility:** Designed for employees, students, mentors, volunteers, and nonprofit contributors
+7. **Reporting & Summaries:** Generate reports or summaries to share contributions, progress, or challenges as needed
+8. **Coach/Assistant Persona:** Supportive tool that helps with personal growth and positive communication
 
 ---
 
@@ -118,6 +119,8 @@ Quick start: [click here](./HOW_TO_USE.md)
 - **Start a Personal Session:** Begin tracking your work, study, or project time with simple clock in/out
 - **Tag Your Activities:** Create projects or tasks to categorize your time (e.g., "Math Homework," "Robot Assembly," "Grant Writing")
 - **Add Reflections:** Include notes about challenges, accomplishments, or context for each session
+- **Connect Your Calendar:** Link Google Calendar or Microsoft Outlook to automatically suggest time entries from your meetings
+- **Review Calendar Events:** Confirm, adjust, or dismiss suggested time entries from your calendar events
 - **Control Your Privacy:** All data stays private unless you choose to share specific summaries or reports
 - **Generate Reports:** Create summaries to share with mentors, teachers, or supervisors when beneficial
 
diff --git a/calendar.md b/calendar.md
new file mode 100644
index 0000000..fc989ce
--- /dev/null
+++ b/calendar.md
@@ -0,0 +1,210 @@
+# Calendar Integration Documentation
+
+TimeHarbor supports integration with external calendar services to help users automatically suggest time entries based on their scheduled meetings and appointments.
+
+## Supported Calendar Providers
+
+### Google Calendar
+- **Module**: googleapis
+- **Authentication**: OAuth 2.0
+- **API**: Google Calendar API v3
+- **Permissions Required**: `https://www.googleapis.com/auth/calendar.readonly`
+
+### Microsoft Outlook/Office 365
+- **Module**: @microsoft/microsoft-graph-client
+- **Authentication**: OAuth 2.0
+- **API**: Microsoft Graph API
+- **Permissions Required**: `https://graph.microsoft.com/calendars.read`
+
+## OAuth Setup and Configuration
+
+### Google Calendar Setup
+1. Create a Google Cloud Project at https://console.cloud.google.com/
+2. Enable the Google Calendar API
+3. Create OAuth 2.0 credentials (Web application)
+4. Add authorized redirect URIs:
+   - `http://localhost:3000/auth/google/callback` (development)
+   - `https://yourdomain.com/auth/google/callback` (production)
+5. Set environment variables:
+   ```
+   GOOGLE_CLIENT_ID=your_client_id
+   GOOGLE_CLIENT_SECRET=your_client_secret
+   ```
+
+### Microsoft Graph Setup
+1. Register an application in Azure Active Directory
+2. Configure API permissions for Microsoft Graph:
+   - Calendars.Read (delegated permission)
+3. Add redirect URIs:
+   - `http://localhost:3000/auth/microsoft/callback` (development)
+   - `https://yourdomain.com/auth/microsoft/callback` (production)
+4. Set environment variables:
+   ```
+   MICROSOFT_CLIENT_ID=your_client_id
+   MICROSOFT_CLIENT_SECRET=your_client_secret
+   ```
+
+## Data Access and Privacy
+
+### What Data is Accessed
+- **Event Title**: For display and time entry suggestions
+- **Event Start/End Time**: To calculate duration and suggest logged time
+- **Event Status**: To filter out cancelled events
+- **Attendee Status**: To confirm user attendance (optional)
+
+### What Data is NOT Accessed
+- Event descriptions or detailed content
+- Private event details beyond title
+- Attendee email addresses or personal information
+- Event locations (unless needed for time entry context)
+
+### Data Storage Policy
+- **OAuth Tokens**: Encrypted and stored securely in user profiles
+- **Calendar Events**: Temporarily cached for suggestion purposes only
+- **Event Details**: Minimal data stored, only what's necessary for time logging
+- **Retention**: Calendar data is not permanently stored; refreshed on each login
+
+### User Control
+- Users can connect/disconnect calendar services at any time
+- Individual events can be dismissed permanently
+- No automatic time logging without explicit user confirmation
+- Users control which events are suggested based on their attendance
+
+## How Calendar Integration Works
+
+### Event Fetching
+1. **On Login**: Fetch events from the past 7 days and next 7 days
+2. **Real-time Updates**: Optional webhook notifications for new/updated events
+3. **Manual Refresh**: Users can manually refresh calendar events
+
+### Event Filtering
+- Only events where the user is an attendee
+- Exclude all-day events
+- Exclude events marked as "free" or "out of office"
+- Exclude cancelled events
+- Only events longer than 15 minutes
+
+### Time Suggestion Logic
+- Suggest the full duration of the meeting for logging
+- Allow users to adjust the time before confirming
+- Pre-fill project/team if event title matches existing projects
+- Suggest activity title based on event title
+
+### Event Confirmation Workflow
+1. Display list of unlogged calendar events
+2. Show event title, time, duration, and suggested log time
+3. Allow user to:
+   - Confirm and log with suggested time
+   - Adjust time before logging
+   - Dismiss event (won't show again)
+   - Snooze event (show again later)
+
+## Security Considerations
+
+### OAuth Token Security
+- Tokens are encrypted before database storage
+- Refresh tokens are rotated regularly
+- Access tokens have limited scope and lifetime
+- Tokens are never logged or exposed in client-side code
+
+### API Rate Limiting
+- Implement exponential backoff for API requests
+- Cache responses to minimize API calls
+- Respect provider rate limits and quotas
+
+### Error Handling
+- Graceful degradation when calendar services are unavailable
+- Clear error messages for authentication failures
+- Automatic token refresh handling
+
+## Webhook Support (Optional Enhancement)
+
+### Google Calendar Webhooks
+- Use Google Calendar Push Notifications
+- Set up webhook endpoint: `/webhooks/google/calendar`
+- Verify webhook signatures for security
+- Handle event notifications in real-time
+
+### Microsoft Graph Webhooks
+- Use Microsoft Graph subscriptions
+- Set up webhook endpoint: `/webhooks/microsoft/calendar`
+- Implement subscription renewal logic
+- Handle event change notifications
+
+## User Interface
+
+### Calendar Connection Settings
+- Located in user profile or main navigation
+- Simple connect/disconnect buttons for each provider
+- Display connection status and last sync time
+- Option to refresh calendar data manually
+
+### Event Confirmation Interface
+- Dedicated section on home page or separate calendar page
+- List of pending calendar events
+- Quick action buttons for each event
+- Batch actions for multiple events
+
+## Installation and Dependencies
+
+### Required NPM Packages
+```bash
+npm install googleapis @microsoft/microsoft-graph-client
+```
+
+### Environment Configuration
+```javascript
+// In settings.json or environment variables
+{
+  "google": {
+    "clientId": "your_google_client_id",
+    "clientSecret": "your_google_client_secret"
+  },
+  "microsoft": {
+    "clientId": "your_microsoft_client_id",
+    "clientSecret": "your_microsoft_client_secret"
+  }
+}
+```
+
+## API Methods
+
+### Client Methods
+- `connectGoogleCalendar()` - Initiate Google OAuth flow
+- `connectMicrosoftCalendar()` - Initiate Microsoft OAuth flow
+- `disconnectCalendar(provider)` - Remove calendar connection
+- `refreshCalendarEvents()` - Manually refresh events
+- `confirmCalendarEvent(eventId, timeData)` - Confirm and log event
+- `dismissCalendarEvent(eventId)` - Dismiss event permanently
+
+### Server Methods
+- `calendar.fetchEvents(provider, dateRange)` - Fetch events from calendar API
+- `calendar.storeTokens(provider, tokens)` - Securely store OAuth tokens
+- `calendar.createTimeEntry(eventData)` - Create time entry from calendar event
+- `calendar.handleWebhook(provider, payload)` - Process webhook notifications
+
+## Privacy Statement for Users
+
+TimeHarbor's calendar integration is designed with your privacy in mind:
+
+- **Read-Only Access**: We only read your calendar data; we never modify or create events
+- **Minimal Data**: We only access event titles, times, and your attendance status
+- **No Permanent Storage**: Calendar events are not permanently stored in our database
+- **User Control**: You decide which events to log and can disconnect your calendar at any time
+- **Secure Storage**: Any temporary data is encrypted and secured
+- **No Sharing**: Your calendar data is never shared with third parties
+
+## Troubleshooting
+
+### Common Issues
+1. **OAuth Authorization Errors**: Check client ID and redirect URI configuration
+2. **API Rate Limits**: Implement exponential backoff and caching
+3. **Token Expiration**: Ensure proper refresh token handling
+4. **Webhook Failures**: Verify webhook URL accessibility and signature validation
+
+### Support
+For calendar integration issues, check:
+1. Environment variable configuration
+2. OAuth application settings in provider console
+3. Network connectivity to calendar APIs
+4. Server logs for detailed error messages
\ No newline at end of file
diff --git a/client/main.html b/client/main.html
index e80a6ac..82c10c6 100644
--- a/client/main.html
+++ b/client/main.html
@@ -23,6 +23,7 @@ <h2 class="text-2xl font-bold">TimeHarbor</h2>
       <a href="/" class="btn btn-ghost hover:bg-primary-focus">Home</a>
       <a href="/teams" class="btn btn-ghost hover:bg-primary-focus">Teams</a>
       <a href="/tickets" class="btn btn-ghost hover:bg-primary-focus">Projects</a>
+      <a href="/calendar" class="btn btn-ghost hover:bg-primary-focus">Calendar</a>
       {{#if currentUser}}
         <button id="logoutBtn" class="btn btn-outline btn-error ml-4" {{logoutBtnAttrs}}>
           {{#if isLogoutLoading}}
@@ -43,6 +44,20 @@ <h2 class="text-2xl font-bold">TimeHarbor</h2>
 </template>
 
 <template name="home">
+  <!-- Calendar Events Notification -->
+  {{#if pendingCalendarEvents.length}}
+    <div class="alert alert-info mb-6">
+      <div class="flex items-center gap-3">
+        <div class="text-xl">📅</div>
+        <div class="flex-1">
+          <div class="font-semibold">Calendar Events Ready for Review</div>
+          <p class="text-sm">You have {{pendingCalendarEvents.length}} calendar events that might need to be logged as time entries.</p>
+        </div>
+        <a href="/calendar" class="btn btn-sm btn-primary">Review Events</a>
+      </div>
+    </div>
+  {{/if}}
+
   <h3 class="text-xl font-semibold mb-4">Your Time Overview</h3>
   <ul class="space-y-4">
     {{#each allClockEvents}}
@@ -248,3 +263,169 @@ <h4 class="text-lg font-semibold mb-2">Create an Account</h4>
     </form>
   </div>
 </template>
+
+<template name="calendar">
+  <h3 class="text-xl font-semibold mb-4">Calendar Integration</h3>
+  
+  <!-- Calendar Connection Status -->
+  <div class="card bg-base-100 shadow p-4 mb-6">
+    <h4 class="text-lg font-bold mb-4">Connected Calendars</h4>
+    <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+      <!-- Google Calendar -->
+      <div class="flex items-center justify-between p-3 border rounded">
+        <div class="flex items-center gap-3">
+          <div class="w-8 h-8 bg-red-500 rounded flex items-center justify-center text-white font-bold">G</div>
+          <div>
+            <div class="font-semibold">Google Calendar</div>
+            {{#if googleCalendarConnected}}
+              <div class="text-sm text-success">Connected - Last sync: {{formatDate googleLastSync}}</div>
+            {{else}}
+              <div class="text-sm text-base-content/70">Not connected</div>
+            {{/if}}
+          </div>
+        </div>
+        <div class="flex gap-2">
+          {{#if googleCalendarConnected}}
+            <button id="refreshGoogleCalendar" class="btn btn-sm btn-outline">Refresh</button>
+            <button id="disconnectGoogleCalendar" class="btn btn-sm btn-error">Disconnect</button>
+          {{else}}
+            <button id="connectGoogleCalendar" class="btn btn-sm btn-primary">Connect</button>
+          {{/if}}
+        </div>
+      </div>
+      
+      <!-- Microsoft Calendar -->
+      <div class="flex items-center justify-between p-3 border rounded">
+        <div class="flex items-center gap-3">
+          <div class="w-8 h-8 bg-blue-500 rounded flex items-center justify-center text-white font-bold">M</div>
+          <div>
+            <div class="font-semibold">Microsoft Outlook</div>
+            {{#if microsoftCalendarConnected}}
+              <div class="text-sm text-success">Connected - Last sync: {{formatDate microsoftLastSync}}</div>
+            {{else}}
+              <div class="text-sm text-base-content/70">Not connected</div>
+            {{/if}}
+          </div>
+        </div>
+        <div class="flex gap-2">
+          {{#if microsoftCalendarConnected}}
+            <button id="refreshMicrosoftCalendar" class="btn btn-sm btn-outline">Refresh</button>
+            <button id="disconnectMicrosoftCalendar" class="btn btn-sm btn-error">Disconnect</button>
+          {{else}}
+            <button id="connectMicrosoftCalendar" class="btn btn-sm btn-primary">Connect</button>
+          {{/if}}
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Pending Calendar Events -->
+  {{#if pendingEvents.length}}
+    <div class="card bg-base-100 shadow p-4 mb-6">
+      <h4 class="text-lg font-bold mb-4">Calendar Events to Review</h4>
+      <p class="text-sm text-base-content/70 mb-4">
+        Review your recent and upcoming calendar events. Confirm attendance and adjust time to log them as activities.
+      </p>
+      
+      <div class="space-y-4">
+        {{#each pendingEvents}}
+          <div class="border rounded p-4">
+            <div class="flex items-start justify-between mb-2">
+              <div class="flex-1">
+                <h5 class="font-semibold">{{title}}</h5>
+                <div class="text-sm text-base-content/70">
+                  {{formatDate startTime}} - {{formatDate endTime}}
+                </div>
+                <div class="text-sm">
+                  <span class="badge badge-neutral">{{formatDuration duration}}</span>
+                  {{#if source}}
+                    <span class="badge badge-outline ml-2">{{source}}</span>
+                  {{/if}}
+                </div>
+              </div>
+              <div class="flex gap-2">
+                <button class="dismiss-event btn btn-sm btn-ghost" data-event-id="{{_id}}">Dismiss</button>
+              </div>
+            </div>
+            
+            <!-- Time Adjustment Form -->
+            <div class="mt-3 p-3 bg-base-200 rounded">
+              <div class="flex items-center gap-4 mb-3">
+                <label class="text-sm font-medium">Time to log:</label>
+                <div class="flex gap-2">
+                  <input type="number" min="0" max="23" value="{{suggestedHours}}" class="input input-sm input-bordered w-16" data-field="hours" />
+                  <span class="self-center">h</span>
+                  <input type="number" min="0" max="59" value="{{suggestedMinutes}}" class="input input-sm input-bordered w-16" data-field="minutes" />
+                  <span class="self-center">m</span>
+                </div>
+              </div>
+              
+              <div class="flex items-center gap-4 mb-3">
+                <label class="text-sm font-medium">Project:</label>
+                <select class="select select-sm select-bordered flex-1" data-field="teamId">
+                  <option value="">Select project (optional)</option>
+                  {{#each ../userTeams}}
+                    <option value="{{_id}}" {{isSelectedTeam _id ../suggestedTeamId}}>{{name}}</option>
+                  {{/each}}
+                </select>
+              </div>
+              
+              <div class="flex items-center gap-4 mb-3">
+                <label class="text-sm font-medium">Activity title:</label>
+                <input type="text" value="{{title}}" class="input input-sm input-bordered flex-1" data-field="activityTitle" />
+              </div>
+              
+              <div class="flex gap-2">
+                <button class="confirm-event btn btn-sm btn-primary" data-event-id="{{_id}}">
+                  Confirm & Log Time
+                </button>
+                <button class="snooze-event btn btn-sm btn-outline" data-event-id="{{_id}}">
+                  Remind Later
+                </button>
+              </div>
+            </div>
+          </div>
+        {{/each}}
+      </div>
+      
+      <!-- Batch Actions -->
+      <div class="mt-4 pt-4 border-t">
+        <div class="flex gap-2">
+          <button id="dismissAllEvents" class="btn btn-sm btn-outline">Dismiss All</button>
+          <button id="refreshCalendarEvents" class="btn btn-sm btn-outline">Refresh Events</button>
+        </div>
+      </div>
+    </div>
+  {{else}}
+    {{#if hasConnectedCalendars}}
+      <div class="card bg-base-100 shadow p-4">
+        <div class="text-center py-8">
+          <div class="text-lg mb-2">📅 No calendar events to review</div>
+          <p class="text-base-content/70 mb-4">
+            You're all caught up! We'll show new events here as they appear.
+          </p>
+          <button id="refreshCalendarEvents" class="btn btn-outline">Check for New Events</button>
+        </div>
+      </div>
+    {{else}}
+      <div class="card bg-base-100 shadow p-4">
+        <div class="text-center py-8">
+          <div class="text-lg mb-2">🔗 Connect Your Calendar</div>
+          <p class="text-base-content/70 mb-4">
+            Connect your Google or Microsoft calendar to automatically suggest time entries based on your meetings.
+          </p>
+          <div class="flex gap-4 justify-center">
+            <button id="connectGoogleCalendar" class="btn btn-primary">
+              <span class="w-4 h-4 bg-red-500 rounded mr-2"></span>
+              Connect Google Calendar
+            </button>
+            <button id="connectMicrosoftCalendar" class="btn btn-primary">
+              <span class="w-4 h-4 bg-blue-500 rounded mr-2"></span>
+              Connect Microsoft Outlook
+            </button>
+          </div>
+        </div>
+      </div>
+    {{/if}}
+  {{/if}}
+</template>
diff --git a/client/main.js b/client/main.js
index fbbe621..dffe6a5 100644
--- a/client/main.js
+++ b/client/main.js
@@ -1,6 +1,6 @@
 import { Template } from 'meteor/templating';
 import { ReactiveVar } from 'meteor/reactive-var';
-import { Teams, Tickets, ClockEvents } from '../collections.js';
+import { Teams, Tickets, ClockEvents, CalendarConnections, CalendarEvents } from '../collections.js';
 
 import './main.html';
 
@@ -611,6 +611,7 @@ Template.home.onCreated(function () {
   this.autorun(() => {
     this.subscribe('userTeams');
     this.subscribe('clockEventsForUser');
+    this.subscribe('pendingCalendarEvents'); // Add calendar events subscription
     // Subscribe to all clock events for teams the user leads
     const leaderTeams = Teams.find({ leader: Meteor.userId() }).fetch();
     const teamIds = leaderTeams.map(t => t._id);
@@ -628,6 +629,12 @@ Template.home.onCreated(function () {
 });
 
 Template.home.helpers({
+  pendingCalendarEvents() {
+    return CalendarEvents.find({ 
+      userId: Meteor.userId(), 
+      status: 'pending' 
+    }).fetch();
+  },
   leaderTeams() {
     return Teams.find({ leader: Meteor.userId() }).fetch();
   },
@@ -681,3 +688,256 @@ Template.home.helpers({
     return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
   },
 });
+
+// Calendar integration
+Template.calendar.onCreated(function () {
+  this.autorun(() => {
+    this.subscribe('userTeams');
+    this.subscribe('calendarConnections');
+    this.subscribe('pendingCalendarEvents');
+  });
+  
+  // Check for OAuth success/error messages in URL
+  const urlParams = new URLSearchParams(window.location.search);
+  const connected = urlParams.get('connected');
+  const error = urlParams.get('error');
+  
+  if (connected) {
+    alert(`${connected} Calendar connected successfully!`);
+    // Clean up URL
+    window.history.replaceState({}, document.title, window.location.pathname);
+  } else if (error) {
+    alert(`Calendar connection failed: ${error}`);
+    // Clean up URL
+    window.history.replaceState({}, document.title, window.location.pathname);
+  }
+});
+
+Template.calendar.helpers({
+  googleCalendarConnected() {
+    const connection = CalendarConnections.findOne({ 
+      userId: Meteor.userId(), 
+      provider: 'google' 
+    });
+    return !!(connection && connection.accessToken);
+  },
+  microsoftCalendarConnected() {
+    const connection = CalendarConnections.findOne({ 
+      userId: Meteor.userId(), 
+      provider: 'microsoft' 
+    });
+    return !!(connection && connection.accessToken);
+  },
+  googleLastSync() {
+    const connection = CalendarConnections.findOne({ 
+      userId: Meteor.userId(), 
+      provider: 'google' 
+    });
+    return connection ? connection.lastSync : null;
+  },
+  microsoftLastSync() {
+    const connection = CalendarConnections.findOne({ 
+      userId: Meteor.userId(), 
+      provider: 'microsoft' 
+    });
+    return connection ? connection.lastSync : null;
+  },
+  hasConnectedCalendars() {
+    const connections = CalendarConnections.find({ 
+      userId: Meteor.userId() 
+    }).count();
+    return connections > 0;
+  },
+  pendingEvents() {
+    return CalendarEvents.find({ 
+      userId: Meteor.userId(), 
+      status: 'pending' 
+    }, { sort: { startTime: 1 } }).fetch().map(event => {
+      // Calculate suggested time
+      const duration = event.endTime - event.startTime;
+      const hours = Math.floor(duration / (1000 * 60 * 60));
+      const minutes = Math.floor((duration % (1000 * 60 * 60)) / (1000 * 60));
+      
+      // Try to match project by event title
+      const userTeams = Teams.find({ members: Meteor.userId() }).fetch();
+      const suggestedTeam = userTeams.find(team => 
+        event.title.toLowerCase().includes(team.name.toLowerCase())
+      );
+      
+      return {
+        ...event,
+        suggestedHours: hours,
+        suggestedMinutes: minutes,
+        suggestedTeamId: suggestedTeam ? suggestedTeam._id : null,
+        duration: duration
+      };
+    });
+  },
+  userTeams() {
+    return Teams.find({ members: Meteor.userId() }).fetch();
+  },
+  formatDate(timestamp) {
+    if (!timestamp) return '';
+    const date = new Date(timestamp);
+    return date.toLocaleString();
+  },
+  formatDuration(milliseconds) {
+    const hours = Math.floor(milliseconds / (1000 * 60 * 60));
+    const minutes = Math.floor((milliseconds % (1000 * 60 * 60)) / (1000 * 60));
+    if (hours > 0) {
+      return `${hours}h ${minutes}m`;
+    }
+    return `${minutes}m`;
+  },
+  eq(a, b) {
+    return a === b;
+  },
+  isSelectedTeam(teamId, suggestedTeamId) {
+    return teamId === suggestedTeamId ? 'selected' : '';
+  }
+});
+
+Template.calendar.events({
+  'click #connectGoogleCalendar'(event, instance) {
+    Meteor.call('calendar.initiateOAuth', 'google', (err, result) => {
+      if (err) {
+        alert('Failed to connect Google Calendar: ' + err.reason);
+      } else {
+        // Redirect to OAuth URL
+        window.location.href = result.authUrl;
+      }
+    });
+  },
+  
+  'click #connectMicrosoftCalendar'(event, instance) {
+    Meteor.call('calendar.initiateOAuth', 'microsoft', (err, result) => {
+      if (err) {
+        alert('Failed to connect Microsoft Calendar: ' + err.reason);
+      } else {
+        // Redirect to OAuth URL
+        window.location.href = result.authUrl;
+      }
+    });
+  },
+  
+  'click #disconnectGoogleCalendar'(event, instance) {
+    if (confirm('Are you sure you want to disconnect your Google Calendar?')) {
+      Meteor.call('calendar.disconnect', 'google', (err) => {
+        if (err) {
+          alert('Failed to disconnect: ' + err.reason);
+        } else {
+          alert('Google Calendar disconnected successfully');
+        }
+      });
+    }
+  },
+  
+  'click #disconnectMicrosoftCalendar'(event, instance) {
+    if (confirm('Are you sure you want to disconnect your Microsoft Calendar?')) {
+      Meteor.call('calendar.disconnect', 'microsoft', (err) => {
+        if (err) {
+          alert('Failed to disconnect: ' + err.reason);
+        } else {
+          alert('Microsoft Calendar disconnected successfully');
+        }
+      });
+    }
+  },
+  
+  'click #refreshGoogleCalendar'(event, instance) {
+    Meteor.call('calendar.refreshEvents', 'google', (err) => {
+      if (err) {
+        alert('Failed to refresh Google Calendar: ' + err.reason);
+      } else {
+        alert('Google Calendar refreshed successfully');
+      }
+    });
+  },
+  
+  'click #refreshMicrosoftCalendar'(event, instance) {
+    Meteor.call('calendar.refreshEvents', 'microsoft', (err) => {
+      if (err) {
+        alert('Failed to refresh Microsoft Calendar: ' + err.reason);
+      } else {
+        alert('Microsoft Calendar refreshed successfully');
+      }
+    });
+  },
+  
+  'click #refreshCalendarEvents'(event, instance) {
+    Meteor.call('calendar.refreshAllEvents', (err) => {
+      if (err) {
+        alert('Failed to refresh calendar events: ' + err.reason);
+      } else {
+        alert('Calendar events refreshed successfully');
+      }
+    });
+  },
+  
+  'click .confirm-event'(event, instance) {
+    const eventId = event.currentTarget.dataset.eventId;
+    const eventCard = event.currentTarget.closest('.border');
+    
+    // Collect form data from the event card
+    const hours = parseInt(eventCard.querySelector('[data-field="hours"]').value) || 0;
+    const minutes = parseInt(eventCard.querySelector('[data-field="minutes"]').value) || 0;
+    const teamId = eventCard.querySelector('[data-field="teamId"]').value;
+    const activityTitle = eventCard.querySelector('[data-field="activityTitle"]').value;
+    
+    const timeData = {
+      hours,
+      minutes,
+      teamId: teamId || null,
+      activityTitle: activityTitle.trim()
+    };
+    
+    if (!timeData.activityTitle) {
+      alert('Please enter an activity title');
+      return;
+    }
+    
+    if (timeData.teamId && (timeData.hours > 0 || timeData.minutes > 0)) {
+      Meteor.call('calendar.confirmEvent', eventId, timeData, (err) => {
+        if (err) {
+          alert('Failed to log calendar event: ' + err.reason);
+        } else {
+          alert('Calendar event logged successfully!');
+        }
+      });
+    } else if (!timeData.teamId) {
+      alert('Please select a project to log time against');
+    } else {
+      alert('Please enter time to log (hours and/or minutes)');
+    }
+  },
+  
+  'click .dismiss-event'(event, instance) {
+    const eventId = event.currentTarget.dataset.eventId;
+    Meteor.call('calendar.dismissEvent', eventId, (err) => {
+      if (err) {
+        alert('Failed to dismiss event: ' + err.reason);
+      }
+    });
+  },
+  
+  'click .snooze-event'(event, instance) {
+    const eventId = event.currentTarget.dataset.eventId;
+    Meteor.call('calendar.snoozeEvent', eventId, (err) => {
+      if (err) {
+        alert('Failed to snooze event: ' + err.reason);
+      }
+    });
+  },
+  
+  'click #dismissAllEvents'(event, instance) {
+    if (confirm('Are you sure you want to dismiss all pending calendar events?')) {
+      Meteor.call('calendar.dismissAllEvents', (err) => {
+        if (err) {
+          alert('Failed to dismiss events: ' + err.reason);
+        } else {
+          alert('All events dismissed');
+        }
+      });
+    }
+  }
+});
diff --git a/collections.js b/collections.js
index 853e1f9..1dda881 100644
--- a/collections.js
+++ b/collections.js
@@ -5,3 +5,7 @@ export const Teams = new Mongo.Collection('teams');
 export const Sessions = new Mongo.Collection('sessions');
 
 export const ClockEvents = new Mongo.Collection('clockevents');
+
+// Calendar integration collections
+export const CalendarConnections = new Mongo.Collection('calendarconnections');
+export const CalendarEvents = new Mongo.Collection('calendarevents');
diff --git a/package-lock.json b/package-lock.json
index ac5af6e..baf672b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,10 +1,10 @@
 {
-  "name": "meteor-app",
+  "name": "timeharbor",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "meteor-app",
+      "name": "timeharbor",
       "dependencies": {
         "@babel/runtime": "^7.17.9",
         "@tailwindcss/postcss": "^4.1.7",
diff --git a/package.json b/package.json
index f454e2c..4e887c5 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.17.9",
+    "@microsoft/microsoft-graph-client": "^3.0.7",
     "@tailwindcss/postcss": "^4.1.7",
+    "googleapis": "^143.0.0",
     "jquery": "^3.6.0",
     "meteor-node-stubs": "^1.2.1",
     "postcss-load-config": "^6.0.1"
diff --git a/server/main.js b/server/main.js
index 4c07502..e4ef84f 100644
--- a/server/main.js
+++ b/server/main.js
@@ -1,7 +1,10 @@
 import { Meteor } from 'meteor/meteor';
 import { Accounts } from 'meteor/accounts-base';
-import { check } from 'meteor/check';
-import { Tickets, Teams, Sessions, ClockEvents } from '../collections.js';
+import { check, Match } from 'meteor/check';
+import { Tickets, Teams, Sessions, ClockEvents, CalendarConnections, CalendarEvents } from '../collections.js';
+
+// Import webhook handlers
+import './webhooks.js';
 
 function generateTeamCode() {
   // Simple random code, can be improved for production
@@ -29,6 +32,23 @@ Meteor.startup(async () => {
     await Teams.updateAsync(team._id, { $set: { code } });
   }
   
+  // Create demo calendar connections for existing users (for demo purposes)
+  if (await CalendarConnections.find().countAsync() === 0) {
+    const users = await Meteor.users.find().fetchAsync();
+    for (const user of users) {
+      // Create a mock Google calendar connection
+      await CalendarConnections.insertAsync({
+        userId: user._id,
+        provider: 'google',
+        accessToken: 'mock-google-token',
+        refreshToken: 'mock-google-refresh',
+        expiresAt: new Date(Date.now() + 3600 * 1000),
+        lastSync: new Date(),
+        createdAt: new Date()
+      });
+    }
+  }
+  
   // Create a unique index on team name (case-insensitive)
   try {
     await Teams.rawCollection().createIndex(
@@ -91,6 +111,20 @@ Meteor.publish('usersByIds', async function (userIds) {
   return Meteor.users.find({ _id: { $in: filteredUserIds } }, { fields: { username: 1 } });
 });
 
+// Calendar integration publications
+Meteor.publish('calendarConnections', function () {
+  if (!this.userId) return this.ready();
+  return CalendarConnections.find({ userId: this.userId });
+});
+
+Meteor.publish('pendingCalendarEvents', function () {
+  if (!this.userId) return this.ready();
+  return CalendarEvents.find({ 
+    userId: this.userId, 
+    status: { $in: ['pending', 'snoozed'] }
+  });
+});
+
 Meteor.methods({
   async joinTeamWithCode(teamCode) {
     check(teamCode, String);
@@ -375,4 +409,221 @@ Meteor.methods({
       );
     }
   },
+  
+  // Calendar integration methods
+  async 'calendar.initiateOAuth'(provider) {
+    check(provider, String);
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    // Generate OAuth URL based on provider
+    const baseUrl = Meteor.absoluteUrl();
+    const redirectUri = `${baseUrl}auth/${provider}/callback`;
+    
+    if (provider === 'google') {
+      const clientId = Meteor.settings?.google?.clientId || process.env.GOOGLE_CLIENT_ID;
+      if (!clientId) {
+        throw new Meteor.Error('config-error', 'Google Calendar integration not configured');
+      }
+      
+      const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?` +
+        `response_type=code&` +
+        `client_id=${clientId}&` +
+        `redirect_uri=${encodeURIComponent(redirectUri)}&` +
+        `scope=${encodeURIComponent('https://www.googleapis.com/auth/calendar.readonly')}&` +
+        `access_type=offline&` +
+        `state=${this.userId}`;
+      
+      return { authUrl };
+    } else if (provider === 'microsoft') {
+      const clientId = Meteor.settings?.microsoft?.clientId || process.env.MICROSOFT_CLIENT_ID;
+      if (!clientId) {
+        throw new Meteor.Error('config-error', 'Microsoft Calendar integration not configured');
+      }
+      
+      const authUrl = `https://login.microsoftonline.com/common/oauth2/v2.0/authorize?` +
+        `response_type=code&` +
+        `client_id=${clientId}&` +
+        `redirect_uri=${encodeURIComponent(redirectUri)}&` +
+        `scope=${encodeURIComponent('https://graph.microsoft.com/calendars.read')}&` +
+        `state=${this.userId}`;
+      
+      return { authUrl };
+    } else {
+      throw new Meteor.Error('invalid-provider', 'Unsupported calendar provider');
+    }
+  },
+  
+  async 'calendar.disconnect'(provider) {
+    check(provider, String);
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    // Remove the calendar connection
+    await CalendarConnections.removeAsync({ userId: this.userId, provider });
+    
+    // Remove pending events from this provider
+    await CalendarEvents.removeAsync({ userId: this.userId, source: provider });
+  },
+  
+  async 'calendar.refreshEvents'(provider) {
+    check(provider, String);
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    const connection = await CalendarConnections.findOneAsync({ 
+      userId: this.userId, 
+      provider 
+    });
+    
+    if (!connection || !connection.accessToken) {
+      throw new Meteor.Error('not-connected', `${provider} calendar not connected`);
+    }
+    
+    // This would implement the actual API calls to fetch events
+    // For now, we'll create mock events for demonstration
+    const mockEvents = [
+      {
+        calendarEventId: `mock-${provider}-1`,
+        title: 'Team Meeting',
+        startTime: new Date(Date.now() + 1000 * 60 * 60 * 2), // 2 hours from now
+        endTime: new Date(Date.now() + 1000 * 60 * 60 * 3), // 3 hours from now
+        source: provider,
+        userId: this.userId,
+        status: 'pending',
+        createdAt: new Date()
+      },
+      {
+        calendarEventId: `mock-${provider}-2`,
+        title: 'Project Review',
+        startTime: new Date(Date.now() - 1000 * 60 * 60 * 24), // Yesterday
+        endTime: new Date(Date.now() - 1000 * 60 * 60 * 23), // Yesterday + 1 hour
+        source: provider,
+        userId: this.userId,
+        status: 'pending',
+        createdAt: new Date()
+      }
+    ];
+    
+    // Insert mock events that don't already exist
+    for (const event of mockEvents) {
+      const existing = await CalendarEvents.findOneAsync({
+        userId: this.userId,
+        calendarEventId: event.calendarEventId
+      });
+      
+      if (!existing) {
+        await CalendarEvents.insertAsync(event);
+      }
+    }
+    
+    // Update last sync time
+    await CalendarConnections.updateAsync(
+      { userId: this.userId, provider },
+      { $set: { lastSync: new Date() } }
+    );
+  },
+  
+  async 'calendar.refreshAllEvents'() {
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    const connections = await CalendarConnections.find({ userId: this.userId }).fetchAsync();
+    
+    for (const connection of connections) {
+      try {
+        await Meteor.call('calendar.refreshEvents', connection.provider);
+      } catch (error) {
+        console.error(`Failed to refresh ${connection.provider} events:`, error);
+      }
+    }
+  },
+  
+  async 'calendar.confirmEvent'(eventId, timeData) {
+    check(eventId, String);
+    check(timeData, {
+      hours: Number,
+      minutes: Number,
+      teamId: Match.Maybe(String),
+      activityTitle: String
+    });
+    
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    const event = await CalendarEvents.findOneAsync({
+      _id: eventId,
+      userId: this.userId
+    });
+    
+    if (!event) {
+      throw new Meteor.Error('not-found', 'Calendar event not found');
+    }
+    
+    if (!timeData.teamId) {
+      throw new Meteor.Error('invalid-data', 'Team ID is required');
+    }
+    
+    // Verify user is member of the team
+    const team = await Teams.findOneAsync({ 
+      _id: timeData.teamId, 
+      members: this.userId 
+    });
+    
+    if (!team) {
+      throw new Meteor.Error('not-authorized', 'You are not a member of this team');
+    }
+    
+    // Create a ticket/activity for this calendar event
+    const accumulatedTime = (timeData.hours * 3600) + (timeData.minutes * 60);
+    
+    const ticketId = await Tickets.insertAsync({
+      teamId: timeData.teamId,
+      title: timeData.activityTitle,
+      github: `Calendar event: ${event.title}`,
+      accumulatedTime,
+      createdBy: this.userId,
+      createdAt: new Date(),
+      calendarEventId: event._id // Link to calendar event
+    });
+    
+    // Mark the calendar event as confirmed
+    await CalendarEvents.updateAsync(eventId, {
+      $set: { 
+        status: 'confirmed', 
+        confirmedAt: new Date(),
+        ticketId: ticketId
+      }
+    });
+    
+    return ticketId;
+  },
+  
+  async 'calendar.dismissEvent'(eventId) {
+    check(eventId, String);
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    await CalendarEvents.updateAsync(
+      { _id: eventId, userId: this.userId },
+      { $set: { status: 'dismissed', dismissedAt: new Date() } }
+    );
+  },
+  
+  async 'calendar.snoozeEvent'(eventId) {
+    check(eventId, String);
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    // Snooze for 24 hours
+    const snoozeUntil = new Date(Date.now() + 24 * 60 * 60 * 1000);
+    
+    await CalendarEvents.updateAsync(
+      { _id: eventId, userId: this.userId },
+      { $set: { status: 'snoozed', snoozeUntil } }
+    );
+  },
+  
+  async 'calendar.dismissAllEvents'() {
+    if (!this.userId) throw new Meteor.Error('not-authorized');
+    
+    await CalendarEvents.updateAsync(
+      { userId: this.userId, status: 'pending' },
+      { $set: { status: 'dismissed', dismissedAt: new Date() } },
+      { multi: true }
+    );
+  }
 });
diff --git a/server/webhooks.js b/server/webhooks.js
new file mode 100644
index 0000000..d849a14
--- /dev/null
+++ b/server/webhooks.js
@@ -0,0 +1,219 @@
+import { WebApp } from 'meteor/webapp';
+import { CalendarConnections, CalendarEvents } from '../collections.js';
+
+// Webhook endpoint for Google Calendar push notifications
+WebApp.connectHandlers.use('/webhooks/google/calendar', async (req, res) => {
+  if (req.method !== 'POST') {
+    res.writeHead(405, { 'Content-Type': 'text/plain' });
+    res.end('Method Not Allowed');
+    return;
+  }
+
+  try {
+    // Verify Google webhook signature if configured
+    const channelId = req.headers['x-goog-channel-id'];
+    const resourceId = req.headers['x-goog-resource-id'];
+    const resourceState = req.headers['x-goog-resource-state'];
+
+    console.log('Google Calendar webhook received:', {
+      channelId,
+      resourceId,
+      resourceState
+    });
+
+    // For demo purposes, we'll just trigger a refresh for all Google calendar connections
+    if (resourceState === 'exists') {
+      const connections = await CalendarConnections.find({ 
+        provider: 'google',
+        'webhookChannelId': channelId 
+      }).fetchAsync();
+
+      for (const connection of connections) {
+        // Trigger calendar refresh for this user
+        Meteor.call('calendar.refreshEvents', 'google', { userId: connection.userId });
+      }
+    }
+
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('OK');
+  } catch (error) {
+    console.error('Google Calendar webhook error:', error);
+    res.writeHead(500, { 'Content-Type': 'text/plain' });
+    res.end('Internal Server Error');
+  }
+});
+
+// Webhook endpoint for Microsoft Graph calendar notifications
+WebApp.connectHandlers.use('/webhooks/microsoft/calendar', async (req, res) => {
+  if (req.method === 'GET') {
+    // Microsoft Graph webhook validation
+    const validationToken = req.query.validationToken;
+    if (validationToken) {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end(validationToken);
+      return;
+    }
+  }
+
+  if (req.method !== 'POST') {
+    res.writeHead(405, { 'Content-Type': 'text/plain' });
+    res.end('Method Not Allowed');
+    return;
+  }
+
+  try {
+    let body = '';
+    req.on('data', chunk => {
+      body += chunk.toString();
+    });
+
+    req.on('end', async () => {
+      try {
+        const notification = JSON.parse(body);
+        console.log('Microsoft Calendar webhook received:', notification);
+
+        // Process each notification in the value array
+        if (notification.value && Array.isArray(notification.value)) {
+          for (const change of notification.value) {
+            // Find connection by subscription ID
+            const connection = await CalendarConnections.findOneAsync({
+              provider: 'microsoft',
+              'webhookSubscriptionId': change.subscriptionId
+            });
+
+            if (connection) {
+              // Trigger calendar refresh for this user
+              Meteor.call('calendar.refreshEvents', 'microsoft', { userId: connection.userId });
+            }
+          }
+        }
+
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end('OK');
+      } catch (parseError) {
+        console.error('Microsoft Calendar webhook parse error:', parseError);
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.end('Bad Request');
+      }
+    });
+  } catch (error) {
+    console.error('Microsoft Calendar webhook error:', error);
+    res.writeHead(500, { 'Content-Type': 'text/plain' });
+    res.end('Internal Server Error');
+  }
+});
+
+// OAuth callback handlers
+WebApp.connectHandlers.use('/auth/google/callback', async (req, res) => {
+  try {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const code = url.searchParams.get('code');
+    const state = url.searchParams.get('state'); // This should be the userId
+    const error = url.searchParams.get('error');
+
+    if (error) {
+      res.writeHead(302, { 'Location': '/calendar?error=' + encodeURIComponent(error) });
+      res.end();
+      return;
+    }
+
+    if (code && state) {
+      // Exchange code for tokens (mock implementation)
+      const mockTokens = {
+        access_token: 'mock-google-access-token-' + Date.now(),
+        refresh_token: 'mock-google-refresh-token-' + Date.now(),
+        expires_in: 3600
+      };
+
+      // Store the connection
+      await CalendarConnections.upsertAsync(
+        { userId: state, provider: 'google' },
+        {
+          $set: {
+            accessToken: mockTokens.access_token,
+            refreshToken: mockTokens.refresh_token,
+            expiresAt: new Date(Date.now() + mockTokens.expires_in * 1000),
+            lastSync: new Date(),
+            updatedAt: new Date()
+          },
+          $setOnInsert: {
+            provider: 'google',
+            userId: state,
+            createdAt: new Date()
+          }
+        }
+      );
+
+      // Redirect back to calendar page with success
+      res.writeHead(302, { 'Location': '/calendar?connected=google' });
+      res.end();
+    } else {
+      res.writeHead(302, { 'Location': '/calendar?error=missing_code' });
+      res.end();
+    }
+  } catch (error) {
+    console.error('Google OAuth callback error:', error);
+    res.writeHead(302, { 'Location': '/calendar?error=server_error' });
+    res.end();
+  }
+});
+
+WebApp.connectHandlers.use('/auth/microsoft/callback', async (req, res) => {
+  try {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const code = url.searchParams.get('code');
+    const state = url.searchParams.get('state'); // This should be the userId
+    const error = url.searchParams.get('error');
+
+    if (error) {
+      res.writeHead(302, { 'Location': '/calendar?error=' + encodeURIComponent(error) });
+      res.end();
+      return;
+    }
+
+    if (code && state) {
+      // Exchange code for tokens (mock implementation)
+      const mockTokens = {
+        access_token: 'mock-microsoft-access-token-' + Date.now(),
+        refresh_token: 'mock-microsoft-refresh-token-' + Date.now(),
+        expires_in: 3600
+      };
+
+      // Store the connection
+      await CalendarConnections.upsertAsync(
+        { userId: state, provider: 'microsoft' },
+        {
+          $set: {
+            accessToken: mockTokens.access_token,
+            refreshToken: mockTokens.refresh_token,
+            expiresAt: new Date(Date.now() + mockTokens.expires_in * 1000),
+            lastSync: new Date(),
+            updatedAt: new Date()
+          },
+          $setOnInsert: {
+            provider: 'microsoft',
+            userId: state,
+            createdAt: new Date()
+          }
+        }
+      );
+
+      // Redirect back to calendar page with success
+      res.writeHead(302, { 'Location': '/calendar?connected=microsoft' });
+      res.end();
+    } else {
+      res.writeHead(302, { 'Location': '/calendar?error=missing_code' });
+      res.end();
+    }
+  } catch (error) {
+    console.error('Microsoft OAuth callback error:', error);
+    res.writeHead(302, { 'Location': '/calendar?error=server_error' });
+    res.end();
+  }
+});
+
+console.log('Calendar webhook endpoints registered:');
+console.log('- POST /webhooks/google/calendar');
+console.log('- POST /webhooks/microsoft/calendar'); 
+console.log('- GET /auth/google/callback');
+console.log('- GET /auth/microsoft/callback');
\ No newline at end of file
diff --git a/settings-example.json b/settings-example.json
new file mode 100644
index 0000000..54cc920
--- /dev/null
+++ b/settings-example.json
@@ -0,0 +1,22 @@
+{
+  "public": {
+    "calendar": {
+      "googleEnabled": true,
+      "microsoftEnabled": true
+    }
+  },
+  "google": {
+    "clientId": "your_google_client_id_here",
+    "clientSecret": "your_google_client_secret_here"
+  },
+  "microsoft": {
+    "clientId": "your_microsoft_client_id_here",
+    "clientSecret": "your_microsoft_client_secret_here"
+  },
+  "calendar": {
+    "webhookSecret": "your_webhook_secret_here",
+    "syncIntervalMinutes": 60,
+    "eventLookbackDays": 7,
+    "eventLookaheadDays": 7
+  }
+}
\ No newline at end of file
diff --git a/tests/main.js b/tests/main.js
index 70146fe..28b28b2 100644
--- a/tests/main.js
+++ b/tests/main.js
@@ -1,5 +1,5 @@
 import assert from "assert";
-import { Teams } from "../collections.js";
+import { Teams, CalendarConnections, CalendarEvents } from "../collections.js";
 import { Meteor } from "meteor/meteor";
 import { Accounts } from "meteor/accounts-base";
 
@@ -154,5 +154,82 @@ describe("timeharbor", function () {
         assert.strictEqual(team.name, 'Test Project');
       });
     });
+    
+    describe("Calendar integration", function () {
+      let testUserId;
+      
+      beforeEach(async function () {
+        // Clear collections before each test
+        await CalendarConnections.removeAsync({});
+        await CalendarEvents.removeAsync({});
+        await Teams.removeAsync({});
+        await Meteor.users.removeAsync({});
+        
+        // Create a test user
+        testUserId = Accounts.createUser({ username: 'testuser', password: 'password' });
+      });
+      
+      it("should allow creating calendar connections", async function () {
+        const connectionId = await CalendarConnections.insertAsync({
+          userId: testUserId,
+          provider: 'google',
+          accessToken: 'test-token',
+          refreshToken: 'test-refresh',
+          expiresAt: new Date(Date.now() + 3600 * 1000),
+          lastSync: new Date(),
+          createdAt: new Date()
+        });
+        
+        assert(connectionId);
+        
+        const connection = await CalendarConnections.findOneAsync(connectionId);
+        assert.strictEqual(connection.provider, 'google');
+        assert.strictEqual(connection.userId, testUserId);
+      });
+      
+      it("should allow creating and managing calendar events", async function () {
+        // Create a calendar event
+        const eventId = await CalendarEvents.insertAsync({
+          calendarEventId: 'test-event-1',
+          title: 'Test Meeting',
+          startTime: new Date(),
+          endTime: new Date(Date.now() + 3600 * 1000),
+          source: 'google',
+          userId: testUserId,
+          status: 'pending',
+          createdAt: new Date()
+        });
+        
+        assert(eventId);
+        
+        const event = await CalendarEvents.findOneAsync(eventId);
+        assert.strictEqual(event.title, 'Test Meeting');
+        assert.strictEqual(event.status, 'pending');
+        assert.strictEqual(event.userId, testUserId);
+      });
+      
+      it("should properly dismiss calendar events", async function () {
+        // Create a calendar event
+        const eventId = await CalendarEvents.insertAsync({
+          calendarEventId: 'test-event-2',
+          title: 'Test Meeting 2',
+          startTime: new Date(),
+          endTime: new Date(Date.now() + 3600 * 1000),
+          source: 'google',
+          userId: testUserId,
+          status: 'pending',
+          createdAt: new Date()
+        });
+        
+        // Dismiss the event
+        await CalendarEvents.updateAsync(eventId, {
+          $set: { status: 'dismissed', dismissedAt: new Date() }
+        });
+        
+        const event = await CalendarEvents.findOneAsync(eventId);
+        assert.strictEqual(event.status, 'dismissed');
+        assert(event.dismissedAt);
+      });
+    });
   }
 });