refactor(mcp): extract all MCP tools into dedicated modules and add shared helpers

server/src/mcp/tools/_shared.ts

@@ -0,0 +1,51 @@
+import { broadcast } from '../../websocket';
+
+export function safeBroadcast(tripId: number, event: string, payload: Record<string, unknown>): void {
+  try {
+    broadcast(tripId, event, payload);
+  } catch (err) {
+    console.error(`[MCP] broadcast failed for ${event}:`, err?.message ?? err);
+  }
+}
+
+export const MAX_MCP_TRIP_DAYS = 90;
+
+export const TOOL_ANNOTATIONS_READONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false,
+} as const;
+
+export const TOOL_ANNOTATIONS_WRITE = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false,
+} as const;
+
+export const TOOL_ANNOTATIONS_DELETE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: false,
+} as const;
+
+export const TOOL_ANNOTATIONS_NON_IDEMPOTENT = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false,
+} as const;
+
+export function demoDenied() {
+  return { content: [{ type: 'text' as const, text: 'Write operations are disabled in demo mode.' }], isError: true };
+}
+
+export function noAccess() {
+  return { content: [{ type: 'text' as const, text: 'Trip not found or access denied.' }], isError: true };
+}
+
+export function ok(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
+}

server/src/mcp/tools/assignments.ts

@@ -0,0 +1,175 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  dayExists, placeExists, createAssignment, assignmentExistsInDay,
+  deleteAssignment, reorderAssignments, getAssignmentForTrip, updateTime,
+  moveAssignment,
+  getParticipants as getAssignmentParticipants,
+  setParticipants as setAssignmentParticipants,
+} from '../../services/assignmentService';
+import { getDay } from '../../services/dayService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerAssignmentTools(server: McpServer, userId: number): void {
+  // --- ASSIGNMENTS ---
+
+  server.registerTool(
+    'assign_place_to_day',
+    {
+      description: 'Assign a place to a specific day in a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        placeId: z.number().int().positive(),
+        notes: z.string().max(500).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, dayId, placeId, notes }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      if (!dayExists(dayId, tripId)) return { content: [{ type: 'text' as const, text: 'Day not found.' }], isError: true };
+      if (!placeExists(placeId, tripId)) return { content: [{ type: 'text' as const, text: 'Place not found.' }], isError: true };
+      const assignment = createAssignment(dayId, placeId, notes || null);
+      safeBroadcast(tripId, 'assignment:created', { assignment });
+      return ok({ assignment });
+    }
+  );
+
+  server.registerTool(
+    'unassign_place',
+    {
+      description: 'Remove a place assignment from a day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        assignmentId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, dayId, assignmentId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      if (!assignmentExistsInDay(assignmentId, dayId, tripId))
+        return { content: [{ type: 'text' as const, text: 'Assignment not found.' }], isError: true };
+      deleteAssignment(assignmentId);
+      safeBroadcast(tripId, 'assignment:deleted', { assignmentId, dayId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'update_assignment_time',
+    {
+      description: 'Set the start and/or end time for a place assignment on a day (e.g. "09:00", "11:30"). Pass null to clear a time.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        assignmentId: z.number().int().positive(),
+        place_time: z.string().max(50).nullable().optional().describe('Start time (e.g. "09:00"), or null to clear'),
+        end_time: z.string().max(50).nullable().optional().describe('End time (e.g. "11:00"), or null to clear'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, assignmentId, place_time, end_time }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const existing = getAssignmentForTrip(assignmentId, tripId);
+      if (!existing) return { content: [{ type: 'text' as const, text: 'Assignment not found.' }], isError: true };
+      const assignment = updateTime(
+        assignmentId,
+        place_time !== undefined ? place_time : (existing as any).assignment_time,
+        end_time !== undefined ? end_time : (existing as any).assignment_end_time
+      );
+      safeBroadcast(tripId, 'assignment:updated', { assignment });
+      return ok({ assignment });
+    }
+  );
+
+  server.registerTool(
+    'move_assignment',
+    {
+      description: 'Move a place assignment to a different day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        assignmentId: z.number().int().positive(),
+        newDayId: z.number().int().positive(),
+        oldDayId: z.number().int().positive(),
+        orderIndex: z.number().int().min(0).optional().default(0),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, assignmentId, newDayId, oldDayId, orderIndex }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const result = moveAssignment(assignmentId, newDayId, orderIndex ?? 0, oldDayId);
+      safeBroadcast(tripId, 'assignment:moved', { assignment: result.assignment, oldDayId: result.oldDayId });
+      return ok({ assignment: result.assignment });
+    }
+  );
+
+  server.registerTool(
+    'get_assignment_participants',
+    {
+      description: 'Get the list of users participating in a specific place assignment.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        assignmentId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId, assignmentId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const participants = getAssignmentParticipants(assignmentId);
+      return ok({ participants });
+    }
+  );
+
+  server.registerTool(
+    'set_assignment_participants',
+    {
+      description: 'Set the participants for a place assignment (replaces current list).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        assignmentId: z.number().int().positive(),
+        userIds: z.array(z.number().int().positive()).describe('User IDs to set as participants; empty array clears all'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, assignmentId, userIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const participants = setAssignmentParticipants(assignmentId, userIds);
+      safeBroadcast(tripId, 'assignment:participants', { assignmentId, participants });
+      return ok({ participants });
+    }
+  );
+
+  // --- REORDER ---
+
+  server.registerTool(
+    'reorder_day_assignments',
+    {
+      description: 'Reorder places within a day by providing the assignment IDs in the desired order.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        assignmentIds: z.array(z.number().int().positive()).min(1).max(200).describe('Assignment IDs in desired display order'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, dayId, assignmentIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      if (!getDay(dayId, tripId)) return { content: [{ type: 'text' as const, text: 'Day not found.' }], isError: true };
+      reorderAssignments(dayId, assignmentIds);
+      safeBroadcast(tripId, 'assignment:reordered', { dayId, assignmentIds });
+      return ok({ success: true, dayId, order: assignmentIds });
+    }
+  );
+}

server/src/mcp/tools/atlas.ts

@@ -0,0 +1,192 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { isDemoUser } from '../../services/authService';
+import {
+  markCountryVisited, unmarkCountryVisited, createBucketItem, deleteBucketItem,
+  getStats as getAtlasStats, listManuallyVisitedRegions,
+  markRegionVisited, unmarkRegionVisited, getCountryPlaces, updateBucketItem,
+} from '../../services/atlasService';
+import { isAddonEnabled } from '../../services/adminService';
+import {
+  TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  TOOL_ANNOTATIONS_READONLY,
+  demoDenied, ok,
+} from './_shared';
+
+export function registerAtlasTools(server: McpServer, userId: number): void {
+  // --- BUCKET LIST ---
+
+  server.registerTool(
+    'create_bucket_list_item',
+    {
+      description: 'Add a destination to your personal travel bucket list.',
+      inputSchema: {
+        name: z.string().min(1).max(200).describe('Destination or experience name'),
+        lat: z.number().optional(),
+        lng: z.number().optional(),
+        country_code: z.string().length(2).toUpperCase().optional().describe('ISO 3166-1 alpha-2 country code'),
+        notes: z.string().max(1000).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ name, lat, lng, country_code, notes }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const item = createBucketItem(userId, { name, lat, lng, country_code, notes });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'delete_bucket_list_item',
+    {
+      description: 'Remove an item from your travel bucket list.',
+      inputSchema: {
+        itemId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ itemId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const deleted = deleteBucketItem(userId, itemId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Bucket list item not found.' }], isError: true };
+      return ok({ success: true });
+    }
+  );
+
+  // --- ATLAS ---
+
+  server.registerTool(
+    'mark_country_visited',
+    {
+      description: 'Mark a country as visited in your Atlas.',
+      inputSchema: {
+        country_code: z.string().length(2).toUpperCase().describe('ISO 3166-1 alpha-2 country code (e.g. "FR", "JP")'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ country_code }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      markCountryVisited(userId, country_code.toUpperCase());
+      return ok({ success: true, country_code: country_code.toUpperCase() });
+    }
+  );
+
+  server.registerTool(
+    'unmark_country_visited',
+    {
+      description: 'Remove a country from your visited countries in Atlas.',
+      inputSchema: {
+        country_code: z.string().length(2).toUpperCase().describe('ISO 3166-1 alpha-2 country code'),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ country_code }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      unmarkCountryVisited(userId, country_code.toUpperCase());
+      return ok({ success: true, country_code: country_code.toUpperCase() });
+    }
+  );
+
+  // --- ATLAS EXPANDED ---
+
+  if (isAddonEnabled('atlas')) {
+    server.registerTool(
+      'get_atlas_stats',
+      {
+        description: 'Get atlas statistics — total visited countries, region counts, continent breakdown.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const stats = await getAtlasStats(userId);
+        return ok({ stats });
+      }
+    );
+
+    server.registerTool(
+      'list_visited_regions',
+      {
+        description: 'List all manually visited sub-country regions for the current user.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const regions = listManuallyVisitedRegions(userId);
+        return ok({ regions });
+      }
+    );
+
+    server.registerTool(
+      'mark_region_visited',
+      {
+        description: 'Mark a sub-country region as visited.',
+        inputSchema: {
+          regionCode: z.string().describe('ISO region code e.g. US-CA'),
+          regionName: z.string(),
+          countryCode: z.string().describe('ISO 3166-1 alpha-2 country code'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ regionCode, regionName, countryCode }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        markRegionVisited(userId, regionCode, regionName, countryCode);
+        const region = listManuallyVisitedRegions(userId).find(r => r.region_code === regionCode);
+        return ok({ region });
+      }
+    );
+
+    server.registerTool(
+      'unmark_region_visited',
+      {
+        description: 'Remove a region from the visited list.',
+        inputSchema: {
+          regionCode: z.string(),
+        },
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async ({ regionCode }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        unmarkRegionVisited(userId, regionCode);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'get_country_atlas_places',
+      {
+        description: 'Get places saved in the user\'s atlas for a specific country.',
+        inputSchema: {
+          countryCode: z.string().describe('ISO 3166-1 alpha-2 country code'),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ countryCode }) => {
+        const result = getCountryPlaces(userId, countryCode);
+        return ok(result);
+      }
+    );
+
+    server.registerTool(
+      'update_bucket_list_item',
+      {
+        description: 'Update a bucket list item (notes, name, target date, location).',
+        inputSchema: {
+          itemId: z.number().int().positive(),
+          name: z.string().optional(),
+          notes: z.string().optional(),
+          lat: z.number().nullable().optional(),
+          lng: z.number().nullable().optional(),
+          country_code: z.string().optional(),
+          target_date: z.string().nullable().optional(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ itemId, name, notes, lat, lng, country_code, target_date }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const item = updateBucketItem(userId, itemId, { name, notes, lat, lng, country_code, target_date });
+        if (!item) return { content: [{ type: 'text' as const, text: 'Bucket list item not found.' }], isError: true };
+        return ok({ item });
+      }
+    );
+  }
+}

server/src/mcp/tools/budget.ts

@@ -0,0 +1,131 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  createBudgetItem, updateBudgetItem, deleteBudgetItem,
+  updateMembers as updateBudgetMembers,
+  toggleMemberPaid,
+} from '../../services/budgetService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerBudgetTools(server: McpServer, userId: number): void {
+  // --- BUDGET ---
+
+  server.registerTool(
+    'create_budget_item',
+    {
+      description: 'Add a budget/expense item to a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        name: z.string().min(1).max(200),
+        category: z.string().max(100).optional().describe('Budget category (e.g. Accommodation, Food, Transport)'),
+        total_price: z.number().nonnegative(),
+        note: z.string().max(500).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, name, category, total_price, note }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = createBudgetItem(tripId, { category, name, total_price, note });
+      safeBroadcast(tripId, 'budget:created', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'delete_budget_item',
+    {
+      description: 'Delete a budget item from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, itemId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = deleteBudgetItem(itemId, tripId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Budget item not found.' }], isError: true };
+      safeBroadcast(tripId, 'budget:deleted', { itemId });
+      return ok({ success: true });
+    }
+  );
+
+  // --- BUDGET (update) ---
+
+  server.registerTool(
+    'update_budget_item',
+    {
+      description: 'Update an existing budget/expense item in a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        name: z.string().min(1).max(200).optional(),
+        category: z.string().max(100).optional(),
+        total_price: z.number().nonnegative().optional(),
+        persons: z.number().int().positive().nullable().optional(),
+        days: z.number().int().positive().nullable().optional(),
+        note: z.string().max(500).nullable().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, name, category, total_price, persons, days, note }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = updateBudgetItem(itemId, tripId, { name, category, total_price, persons, days, note });
+      if (!item) return { content: [{ type: 'text' as const, text: 'Budget item not found.' }], isError: true };
+      safeBroadcast(tripId, 'budget:updated', { item });
+      return ok({ item });
+    }
+  );
+
+  // --- BUDGET ADVANCED ---
+
+  server.registerTool(
+    'set_budget_item_members',
+    {
+      description: 'Set which trip members are splitting a budget item (replaces current member list).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        userIds: z.array(z.number().int().positive()).describe('User IDs splitting this item; empty array clears all'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, userIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = updateBudgetMembers(itemId, tripId, userIds);
+      safeBroadcast(tripId, 'budget:members-updated', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'toggle_budget_member_paid',
+    {
+      description: 'Mark or unmark a member as having paid their share of a budget item.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        memberId: z.number().int().positive().describe('User ID of the member'),
+        paid: z.boolean(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, memberId, paid }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const member = toggleMemberPaid(itemId, memberId, paid);
+      safeBroadcast(tripId, 'budget:member-paid-updated', { itemId, member });
+      return ok({ member });
+    }
+  );
+}

server/src/mcp/tools/collab.ts

@@ -0,0 +1,268 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  createNote as createCollabNote, updateNote as updateCollabNote, deleteNote as deleteCollabNote,
+  listPolls, createPoll, votePoll, closePoll, deletePoll,
+  listMessages, createMessage, deleteMessage, addOrRemoveReaction,
+} from '../../services/collabService';
+import { isAddonEnabled } from '../../services/adminService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT, TOOL_ANNOTATIONS_READONLY,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerCollabTools(server: McpServer, userId: number): void {
+  // --- COLLAB NOTES ---
+
+  server.registerTool(
+    'create_collab_note',
+    {
+      description: 'Create a shared collaborative note on a trip (visible to all trip members in the Collab tab).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        title: z.string().min(1).max(200),
+        content: z.string().max(10000).optional(),
+        category: z.string().max(100).optional().describe('Note category (e.g. "Ideas", "To-do", "General")'),
+        color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe('Hex color for the note card'),
+        pinned: z.boolean().optional().default(false).describe('Pin the note to the top'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, title, content, category, color, pinned }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const note = createCollabNote(tripId, userId, { title, content, category, color, pinned });
+      safeBroadcast(tripId, 'collab:note:created', { note });
+      return ok({ note });
+    }
+  );
+
+  server.registerTool(
+    'update_collab_note',
+    {
+      description: 'Edit an existing collaborative note on a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        noteId: z.number().int().positive(),
+        title: z.string().min(1).max(200).optional(),
+        content: z.string().max(10000).optional(),
+        category: z.string().max(100).optional(),
+        color: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe('Hex color for the note card'),
+        pinned: z.boolean().optional().describe('Pin the note to the top'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, noteId, title, content, category, color, pinned }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const note = updateCollabNote(tripId, noteId, { title, content, category, color, pinned });
+      if (!note) return { content: [{ type: 'text' as const, text: 'Note not found.' }], isError: true };
+      safeBroadcast(tripId, 'collab:note:updated', { note });
+      return ok({ note });
+    }
+  );
+
+  server.registerTool(
+    'delete_collab_note',
+    {
+      description: 'Delete a collaborative note from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        noteId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, noteId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = deleteCollabNote(tripId, noteId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Note not found.' }], isError: true };
+      safeBroadcast(tripId, 'collab:note:deleted', { noteId });
+      return ok({ success: true });
+    }
+  );
+
+  // --- COLLAB POLLS & CHAT ---
+
+  if (isAddonEnabled('collab')) {
+    server.registerTool(
+      'list_collab_polls',
+      {
+        description: 'List all polls for a trip.',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ tripId }) => {
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const polls = listPolls(tripId);
+        return ok({ polls });
+      }
+    );
+
+    server.registerTool(
+      'create_collab_poll',
+      {
+        description: 'Create a new poll in the collab panel.',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          question: z.string().min(1),
+          options: z.array(z.string()).min(2).describe('Poll answer options (at least 2)'),
+          multiple: z.boolean().optional().describe('Allow multiple choice'),
+          deadline: z.string().optional().describe('ISO date string for poll deadline'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ tripId, question, options, multiple, deadline }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const poll = createPoll(tripId, userId, { question, options, multiple, deadline });
+        safeBroadcast(tripId, 'collab:poll:created', { poll });
+        return ok({ poll });
+      }
+    );
+
+    server.registerTool(
+      'vote_collab_poll',
+      {
+        description: 'Vote on a poll option (or remove vote if already voted for that option).',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          pollId: z.number().int().positive(),
+          optionIndex: z.number().int().min(0).describe('Zero-based index of the option to vote for'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ tripId, pollId, optionIndex }) => {
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const result = votePoll(tripId, pollId, userId, optionIndex);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        safeBroadcast(tripId, 'collab:poll:voted', { poll: result.poll });
+        return ok({ poll: result.poll });
+      }
+    );
+
+    server.registerTool(
+      'close_collab_poll',
+      {
+        description: 'Close a poll so no more votes can be cast.',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          pollId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ tripId, pollId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const poll = closePoll(tripId, pollId);
+        if (!poll) return { content: [{ type: 'text' as const, text: 'Poll not found.' }], isError: true };
+        safeBroadcast(tripId, 'collab:poll:closed', { poll });
+        return ok({ poll });
+      }
+    );
+
+    server.registerTool(
+      'delete_collab_poll',
+      {
+        description: 'Delete a poll and all its votes.',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          pollId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async ({ tripId, pollId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const deleted = deletePoll(tripId, pollId);
+        if (!deleted) return { content: [{ type: 'text' as const, text: 'Poll not found.' }], isError: true };
+        safeBroadcast(tripId, 'collab:poll:deleted', { pollId });
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'list_collab_messages',
+      {
+        description: 'List chat messages for a trip (most recent 100, oldest-first).',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          before: z.number().int().positive().optional().describe('Load messages with ID less than this (pagination)'),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ tripId, before }) => {
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const messages = listMessages(tripId, before);
+        return ok({ messages });
+      }
+    );
+
+    server.registerTool(
+      'send_collab_message',
+      {
+        description: "Send a chat message to a trip's collab channel.",
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          text: z.string().min(1),
+          replyTo: z.number().int().positive().optional().describe('Reply to a specific message ID'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ tripId, text, replyTo }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const result = createMessage(tripId, userId, text, replyTo ?? null);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        safeBroadcast(tripId, 'collab:message:created', { message: result.message });
+        return ok({ message: result.message });
+      }
+    );
+
+    server.registerTool(
+      'delete_collab_message',
+      {
+        description: 'Delete a chat message (only the message owner can delete their own messages).',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          messageId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async ({ tripId, messageId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const result = deleteMessage(tripId, messageId, userId);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        safeBroadcast(tripId, 'collab:message:deleted', { messageId, username: result.username });
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'react_collab_message',
+      {
+        description: 'Toggle a reaction emoji on a chat message (adds if not present, removes if already reacted).',
+        inputSchema: {
+          tripId: z.number().int().positive(),
+          messageId: z.number().int().positive(),
+          emoji: z.string().describe('Single emoji character'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ tripId, messageId, emoji }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        if (!canAccessTrip(tripId, userId)) return noAccess();
+        const result = addOrRemoveReaction(messageId, tripId, userId, emoji);
+        if (!result.found) return { content: [{ type: 'text' as const, text: 'Message not found.' }], isError: true };
+        safeBroadcast(tripId, 'collab:message:reacted', { messageId, reactions: result.reactions });
+        return ok({ reactions: result.reactions });
+      }
+    );
+  }
+}

server/src/mcp/tools/days.ts

@@ -0,0 +1,229 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  getDay, updateDay, validateAccommodationRefs,
+  createDay, deleteDay,
+  createAccommodation, getAccommodation, updateAccommodation, deleteAccommodation,
+} from '../../services/dayService';
+import {
+  createNote as createDayNote, getNote as getDayNote, updateNote as updateDayNote,
+  deleteNote as deleteDayNote, dayExists as dayNoteExists,
+} from '../../services/dayNoteService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerDayTools(server: McpServer, userId: number): void {
+  // --- DAYS ---
+
+  server.registerTool(
+    'update_day',
+    {
+      description: 'Set the title of a day in a trip (e.g. "Arrival in Paris", "Free day").',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        title: z.string().max(200).nullable().describe('Day title, or null to clear it'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, dayId, title }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const current = getDay(dayId, tripId);
+      if (!current) return { content: [{ type: 'text' as const, text: 'Day not found.' }], isError: true };
+      const updated = updateDay(dayId, current, title !== undefined ? { title } : {});
+      safeBroadcast(tripId, 'day:updated', { day: updated });
+      return ok({ day: updated });
+    }
+  );
+
+  server.registerTool(
+    'create_day',
+    {
+      description: 'Add a new day to a trip (optionally with a specific date and notes).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        date: z.string().optional().describe('ISO date string YYYY-MM-DD, optional for dateless trips'),
+        notes: z.string().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, date, notes }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const day = createDay(tripId, date, notes);
+      safeBroadcast(tripId, 'day:created', { day });
+      return ok({ day });
+    }
+  );
+
+  server.registerTool(
+    'delete_day',
+    {
+      description: 'Delete a day from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, dayId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      deleteDay(dayId);
+      safeBroadcast(tripId, 'day:deleted', { id: dayId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'create_accommodation',
+    {
+      description: 'Add an accommodation (hotel, Airbnb, etc.) to a trip, linked to a place and a date range.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        place_id: z.number().int().positive().describe('The place to use as the accommodation'),
+        start_day_id: z.number().int().positive().describe('Check-in day ID'),
+        end_day_id: z.number().int().positive().describe('Check-out day ID'),
+        check_in: z.string().max(10).optional().describe('Check-in time e.g. "15:00"'),
+        check_out: z.string().max(10).optional().describe('Check-out time e.g. "11:00"'),
+        confirmation: z.string().max(100).optional(),
+        notes: z.string().max(1000).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, place_id, start_day_id, end_day_id, check_in, check_out, confirmation, notes }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const errors = validateAccommodationRefs(tripId, place_id, start_day_id, end_day_id);
+      if (errors.length > 0) return { content: [{ type: 'text' as const, text: errors.map(e => e.message).join(', ') }], isError: true };
+      const accommodation = createAccommodation(tripId, { place_id, start_day_id, end_day_id, check_in, check_out, confirmation, notes });
+      safeBroadcast(tripId, 'accommodation:created', { accommodation });
+      return ok({ accommodation });
+    }
+  );
+
+  server.registerTool(
+    'update_accommodation',
+    {
+      description: 'Update fields on an existing accommodation.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        accommodationId: z.number().int().positive(),
+        place_id: z.number().int().positive().optional(),
+        start_day_id: z.number().int().positive().optional(),
+        end_day_id: z.number().int().positive().optional(),
+        check_in: z.string().max(10).optional(),
+        check_out: z.string().max(10).optional(),
+        confirmation: z.string().max(100).optional(),
+        notes: z.string().max(1000).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, accommodationId, place_id, start_day_id, end_day_id, check_in, check_out, confirmation, notes }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const existing = getAccommodation(accommodationId, tripId);
+      if (!existing) return { content: [{ type: 'text' as const, text: 'Accommodation not found.' }], isError: true };
+      const accommodation = updateAccommodation(accommodationId, existing, { place_id, start_day_id, end_day_id, check_in, check_out, confirmation, notes });
+      safeBroadcast(tripId, 'accommodation:updated', { accommodation });
+      return ok({ accommodation });
+    }
+  );
+
+  server.registerTool(
+    'delete_accommodation',
+    {
+      description: 'Delete an accommodation from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        accommodationId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, accommodationId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const { linkedReservationId } = deleteAccommodation(accommodationId);
+      safeBroadcast(tripId, 'accommodation:deleted', { id: accommodationId, linkedReservationId });
+      return ok({ success: true, linkedReservationId });
+    }
+  );
+
+  // --- DAY NOTES ---
+
+  server.registerTool(
+    'create_day_note',
+    {
+      description: 'Add a note to a specific day in a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        text: z.string().min(1).max(500),
+        time: z.string().max(150).optional().describe('Time label (e.g. "09:00" or "Morning")'),
+        icon: z.string().optional().describe('Emoji icon for the note'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, dayId, text, time, icon }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      if (!dayNoteExists(dayId, tripId)) return { content: [{ type: 'text' as const, text: 'Day not found.' }], isError: true };
+      const note = createDayNote(dayId, tripId, text, time, icon);
+      safeBroadcast(tripId, 'dayNote:created', { dayId, note });
+      return ok({ note });
+    }
+  );
+
+  server.registerTool(
+    'update_day_note',
+    {
+      description: 'Edit an existing note on a specific day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        noteId: z.number().int().positive(),
+        text: z.string().min(1).max(500).optional(),
+        time: z.string().max(150).nullable().optional().describe('Time label (e.g. "09:00" or "Morning"), or null to clear'),
+        icon: z.string().optional().describe('Emoji icon for the note'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, dayId, noteId, text, time, icon }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const existing = getDayNote(noteId, dayId, tripId);
+      if (!existing) return { content: [{ type: 'text' as const, text: 'Note not found.' }], isError: true };
+      const note = updateDayNote(noteId, existing, { text, time: time !== undefined ? time : undefined, icon });
+      safeBroadcast(tripId, 'dayNote:updated', { dayId, note });
+      return ok({ note });
+    }
+  );
+
+  server.registerTool(
+    'delete_day_note',
+    {
+      description: 'Delete a note from a specific day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        dayId: z.number().int().positive(),
+        noteId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, dayId, noteId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const note = getDayNote(noteId, dayId, tripId);
+      if (!note) return { content: [{ type: 'text' as const, text: 'Note not found.' }], isError: true };
+      deleteDayNote(noteId);
+      safeBroadcast(tripId, 'dayNote:deleted', { noteId, dayId });
+      return ok({ success: true });
+    }
+  );
+}

server/src/mcp/tools/files.ts

@@ -0,0 +1,231 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  listFiles, getFileById, getDeletedFile, updateFile, toggleStarred,
+  softDeleteFile, restoreFile, permanentDeleteFile, emptyTrash,
+  createFileLink, deleteFileLink, getFileLinks,
+} from '../../services/fileService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerFileTools(server: McpServer, userId: number): void {
+  // --- FILES ---
+
+  server.registerTool(
+    'list_files',
+    {
+      description: 'List trip files. By default returns active files; set showTrash=true to list the trash instead.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        showTrash: z.boolean().optional().default(false).describe('List trash instead of active files'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId, showTrash }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const files = listFiles(tripId, showTrash ?? false);
+      return ok({ files });
+    }
+  );
+
+  server.registerTool(
+    'update_file_metadata',
+    {
+      description: 'Update a file\'s metadata: description, linked place, or linked reservation.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+        description: z.string().max(1000).nullable().optional(),
+        place_id: z.number().int().positive().nullable().optional().describe('Link to a place; null to unlink'),
+        reservation_id: z.number().int().positive().nullable().optional().describe('Link to a reservation; null to unlink'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, fileId, description, place_id, reservation_id }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      const updated = updateFile(fileId, file, {
+        description: description !== undefined ? (description ?? undefined) : undefined,
+        place_id: place_id !== undefined ? (place_id !== null ? String(place_id) : null) : undefined,
+        reservation_id: reservation_id !== undefined ? (reservation_id !== null ? String(reservation_id) : null) : undefined,
+      });
+      safeBroadcast(tripId, 'file:updated', { file: updated });
+      return ok({ file: updated });
+    }
+  );
+
+  server.registerTool(
+    'toggle_file_star',
+    {
+      description: 'Toggle the starred status of a file (starred files appear at the top).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, fileId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      const updated = toggleStarred(fileId, file.starred);
+      safeBroadcast(tripId, 'file:updated', { file: updated });
+      return ok({ file: updated });
+    }
+  );
+
+  server.registerTool(
+    'trash_file',
+    {
+      description: 'Move a file to trash (soft delete). Recoverable with restore_file.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, fileId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      softDeleteFile(fileId);
+      safeBroadcast(tripId, 'file:deleted', { fileId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'restore_file',
+    {
+      description: 'Restore a file from trash back to the active file list.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, fileId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getDeletedFile(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found in trash.' }], isError: true };
+      const restored = restoreFile(fileId);
+      safeBroadcast(tripId, 'file:created', { file: restored });
+      return ok({ file: restored });
+    }
+  );
+
+  server.registerTool(
+    'permanent_delete_file',
+    {
+      description: 'Permanently delete a file from trash. This cannot be undone — the file is removed from disk.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, fileId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getDeletedFile(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found in trash.' }], isError: true };
+      permanentDeleteFile(file);
+      safeBroadcast(tripId, 'file:deleted', { fileId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'empty_trash',
+    {
+      description: 'Permanently delete all files in the trash for a trip. Cannot be undone.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = emptyTrash(tripId);
+      return ok({ success: true, deleted });
+    }
+  );
+
+  server.registerTool(
+    'link_file',
+    {
+      description: 'Link a file to a place, reservation, or assignment. The file must belong to the trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+        place_id: z.number().int().positive().optional(),
+        reservation_id: z.number().int().positive().optional(),
+        assignment_id: z.number().int().positive().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, fileId, place_id, reservation_id, assignment_id }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      const links = createFileLink(fileId, {
+        place_id: place_id ? String(place_id) : null,
+        reservation_id: reservation_id ? String(reservation_id) : null,
+        assignment_id: assignment_id ? String(assignment_id) : null,
+      });
+      return ok({ success: true, links });
+    }
+  );
+
+  server.registerTool(
+    'unlink_file',
+    {
+      description: 'Remove a specific link between a file and a place/reservation/assignment. Use list_file_links to get the link ID.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+        linkId: z.number().int().positive().describe('ID of the file link to remove'),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, fileId, linkId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      deleteFileLink(linkId, fileId);
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'list_file_links',
+    {
+      description: 'List all entity links for a file (places, reservations, assignments it is attached to).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        fileId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId, fileId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const file = getFileById(fileId, tripId);
+      if (!file) return { content: [{ type: 'text' as const, text: 'File not found.' }], isError: true };
+      const links = getFileLinks(fileId);
+      return ok({ links });
+    }
+  );
+}

server/src/mcp/tools/mapsWeather.ts

@@ -0,0 +1,109 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { searchPlaces, getPlaceDetails, reverseGeocode, resolveGoogleMapsUrl } from '../../services/mapsService';
+import { getWeather, getDetailedWeather } from '../../services/weatherService';
+import {
+  TOOL_ANNOTATIONS_READONLY,
+  ok,
+} from './_shared';
+
+export function registerMapsWeatherTools(server: McpServer, userId: number): void {
+  // --- MAPS EXTRAS ---
+
+  server.registerTool(
+    'get_place_details',
+    {
+      description: 'Fetch detailed information about a place by its Google Place ID.',
+      inputSchema: {
+        placeId: z.string().describe('Google Place ID'),
+        lang: z.string().optional().default('en'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ placeId, lang }) => {
+      const details = await getPlaceDetails(userId, placeId, lang ?? 'en');
+      if (!details) return { content: [{ type: 'text' as const, text: 'Place not found or maps service not configured.' }], isError: true };
+      return ok({ details });
+    }
+  );
+
+  server.registerTool(
+    'reverse_geocode',
+    {
+      description: 'Get a human-readable address for given coordinates.',
+      inputSchema: {
+        lat: z.number(),
+        lng: z.number(),
+        lang: z.string().optional().default('en'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ lat, lng, lang }) => {
+      const result = await reverseGeocode(String(lat), String(lng), lang ?? 'en');
+      if (!result) return { content: [{ type: 'text' as const, text: 'Reverse geocode failed or maps service not configured.' }], isError: true };
+      return ok(result);
+    }
+  );
+
+  server.registerTool(
+    'resolve_maps_url',
+    {
+      description: 'Resolve a Google Maps share URL to coordinates and place name.',
+      inputSchema: {
+        url: z.string().describe('Google Maps share URL'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ url }) => {
+      const result = await resolveGoogleMapsUrl(url);
+      if (!result) return { content: [{ type: 'text' as const, text: 'Could not resolve URL or maps service not configured.' }], isError: true };
+      return ok(result);
+    }
+  );
+
+  // --- WEATHER ---
+
+  server.registerTool(
+    'get_weather',
+    {
+      description: 'Get weather forecast for a location and date.',
+      inputSchema: {
+        lat: z.number(),
+        lng: z.number(),
+        date: z.string().describe('ISO date YYYY-MM-DD'),
+        lang: z.string().optional().default('en'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ lat, lng, date, lang }) => {
+      try {
+        const weather = await getWeather(String(lat), String(lng), date, lang ?? 'en');
+        return ok({ weather });
+      } catch (err: any) {
+        return { content: [{ type: 'text' as const, text: err?.message ?? 'Weather service not available.' }], isError: true };
+      }
+    }
+  );
+
+  server.registerTool(
+    'get_detailed_weather',
+    {
+      description: 'Get hourly/detailed weather forecast for a location and date.',
+      inputSchema: {
+        lat: z.number(),
+        lng: z.number(),
+        date: z.string().describe('ISO date YYYY-MM-DD'),
+        lang: z.string().optional().default('en'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ lat, lng, date, lang }) => {
+      try {
+        const weather = await getDetailedWeather(String(lat), String(lng), date, lang ?? 'en');
+        return ok({ weather });
+      } catch (err: any) {
+        return { content: [{ type: 'text' as const, text: err?.message ?? 'Weather service not available.' }], isError: true };
+      }
+    }
+  );
+}

server/src/mcp/tools/notifications.ts

@@ -0,0 +1,145 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { isDemoUser } from '../../services/authService';
+import {
+  getNotifications, getUnreadCount,
+  markRead as markNotificationRead, markUnread as markNotificationUnread,
+  markAllRead, deleteNotification, deleteAll as deleteAllNotifications,
+  respondToBoolean,
+} from '../../services/inAppNotifications';
+import {
+  TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, ok,
+} from './_shared';
+
+export function registerNotificationTools(server: McpServer, userId: number): void {
+  // --- NOTIFICATIONS ---
+
+  server.registerTool(
+    'list_notifications',
+    {
+      description: 'List in-app notifications for the current user.',
+      inputSchema: {
+        limit: z.number().int().positive().optional().default(20),
+        offset: z.number().int().min(0).optional().default(0),
+        unread_only: z.boolean().optional().default(false),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ limit, offset, unread_only }) => {
+      const result = getNotifications(userId, { limit: limit ?? 20, offset: offset ?? 0, unreadOnly: unread_only ?? false });
+      return ok(result);
+    }
+  );
+
+  server.registerTool(
+    'get_unread_notification_count',
+    {
+      description: 'Get the number of unread in-app notifications.',
+      inputSchema: {},
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async () => {
+      const count = getUnreadCount(userId);
+      return ok({ count });
+    }
+  );
+
+  server.registerTool(
+    'mark_notification_read',
+    {
+      description: 'Mark a single notification as read.',
+      inputSchema: {
+        notificationId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ notificationId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const success = markNotificationRead(notificationId, userId);
+      if (!success) return { content: [{ type: 'text' as const, text: 'Notification not found.' }], isError: true };
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'mark_notification_unread',
+    {
+      description: 'Mark a single notification as unread.',
+      inputSchema: {
+        notificationId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ notificationId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const success = markNotificationUnread(notificationId, userId);
+      if (!success) return { content: [{ type: 'text' as const, text: 'Notification not found.' }], isError: true };
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'mark_all_notifications_read',
+    {
+      description: "Mark all of the current user's notifications as read.",
+      inputSchema: {},
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async () => {
+      if (isDemoUser(userId)) return demoDenied();
+      const count = markAllRead(userId);
+      return ok({ success: true, count });
+    }
+  );
+
+  server.registerTool(
+    'delete_notification',
+    {
+      description: 'Delete a single in-app notification.',
+      inputSchema: {
+        notificationId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ notificationId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const success = deleteNotification(notificationId, userId);
+      if (!success) return { content: [{ type: 'text' as const, text: 'Notification not found.' }], isError: true };
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'delete_all_notifications',
+    {
+      description: "Delete all in-app notifications for the current user.",
+      inputSchema: {},
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async () => {
+      if (isDemoUser(userId)) return demoDenied();
+      const count = deleteAllNotifications(userId);
+      return ok({ success: true, count });
+    }
+  );
+
+  server.registerTool(
+    'respond_to_notification',
+    {
+      description: 'Respond to a boolean (yes/no) notification such as a trip invite or poll.',
+      inputSchema: {
+        notificationId: z.number().int().positive(),
+        response: z.enum(['positive', 'negative']),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ notificationId, response }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const result = await respondToBoolean(notificationId, userId, response);
+      if (!result.success) return { content: [{ type: 'text' as const, text: result.error ?? 'Failed to respond.' }], isError: true };
+      return ok({ notification: result.notification });
+    }
+  );
+}

server/src/mcp/tools/packing.ts

@@ -0,0 +1,326 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  createItem as createPackingItem, updateItem as updatePackingItem,
+  deleteItem as deletePackingItem,
+  reorderItems as reorderPackingItems,
+  listBags, createBag, updateBag, deleteBag, setBagMembers,
+  getCategoryAssignees as getPackingCategoryAssignees,
+  updateCategoryAssignees as updatePackingCategoryAssignees,
+  applyTemplate, saveAsTemplate, bulkImport,
+} from '../../services/packingService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerPackingTools(server: McpServer, userId: number): void {
+  // --- PACKING ---
+
+  server.registerTool(
+    'create_packing_item',
+    {
+      description: 'Add an item to the packing checklist for a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        name: z.string().min(1).max(200),
+        category: z.string().max(100).optional().describe('Packing category (e.g. Clothes, Electronics)'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, name, category }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = createPackingItem(tripId, { name, category: category || 'General' });
+      safeBroadcast(tripId, 'packing:created', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'toggle_packing_item',
+    {
+      description: 'Check or uncheck a packing item.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        checked: z.boolean(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, checked }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = updatePackingItem(tripId, itemId, { checked: checked ? 1 : 0 }, ['checked']);
+      if (!item) return { content: [{ type: 'text' as const, text: 'Packing item not found.' }], isError: true };
+      safeBroadcast(tripId, 'packing:updated', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'delete_packing_item',
+    {
+      description: 'Remove an item from the packing checklist.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, itemId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = deletePackingItem(tripId, itemId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Packing item not found.' }], isError: true };
+      safeBroadcast(tripId, 'packing:deleted', { itemId });
+      return ok({ success: true });
+    }
+  );
+
+  // --- PACKING (update) ---
+
+  server.registerTool(
+    'update_packing_item',
+    {
+      description: 'Rename a packing item or change its category.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        name: z.string().min(1).max(200).optional(),
+        category: z.string().max(100).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, name, category }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const bodyKeys = ['name', 'category'].filter(k => k === 'name' ? name !== undefined : category !== undefined);
+      const item = updatePackingItem(tripId, itemId, { name, category }, bodyKeys);
+      if (!item) return { content: [{ type: 'text' as const, text: 'Packing item not found.' }], isError: true };
+      safeBroadcast(tripId, 'packing:updated', { item });
+      return ok({ item });
+    }
+  );
+
+  // --- PACKING ADVANCED ---
+
+  server.registerTool(
+    'reorder_packing_items',
+    {
+      description: 'Set the display order of packing items within a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        orderedIds: z.array(z.number().int().positive()).describe('Packing item IDs in desired order'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, orderedIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      reorderPackingItems(tripId, orderedIds);
+      safeBroadcast(tripId, 'packing:reordered', { orderedIds });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'list_packing_bags',
+    {
+      description: 'List all packing bags for a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const bags = listBags(tripId);
+      return ok({ bags });
+    }
+  );
+
+  server.registerTool(
+    'create_packing_bag',
+    {
+      description: 'Create a new packing bag (e.g. "Carry-on", "Checked bag").',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        name: z.string().min(1).max(100),
+        color: z.string().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, name, color }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const bag = createBag(tripId, { name, color });
+      safeBroadcast(tripId, 'packing:bag-created', { bag });
+      return ok({ bag });
+    }
+  );
+
+  server.registerTool(
+    'update_packing_bag',
+    {
+      description: 'Rename or recolor a packing bag.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        bagId: z.number().int().positive(),
+        name: z.string().optional(),
+        color: z.string().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, bagId, name, color }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const fields: Record<string, unknown> = {};
+      const bodyKeys: string[] = [];
+      if (name !== undefined) { fields.name = name; bodyKeys.push('name'); }
+      if (color !== undefined) { fields.color = color; bodyKeys.push('color'); }
+      const bag = updateBag(tripId, bagId, fields, bodyKeys);
+      safeBroadcast(tripId, 'packing:bag-updated', { bag });
+      return ok({ bag });
+    }
+  );
+
+  server.registerTool(
+    'delete_packing_bag',
+    {
+      description: 'Delete a packing bag (items in the bag are unassigned, not deleted).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        bagId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, bagId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      deleteBag(tripId, bagId);
+      safeBroadcast(tripId, 'packing:bag-deleted', { id: bagId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'set_bag_members',
+    {
+      description: 'Assign trip members to a packing bag (determines who packs what bag).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        bagId: z.number().int().positive(),
+        userIds: z.array(z.number().int().positive()),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, bagId, userIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      setBagMembers(tripId, bagId, userIds);
+      safeBroadcast(tripId, 'packing:bag-members-updated', { bagId, userIds });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'get_packing_category_assignees',
+    {
+      description: 'Get which trip members are assigned to each packing category.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const assignees = getPackingCategoryAssignees(tripId);
+      return ok({ assignees });
+    }
+  );
+
+  server.registerTool(
+    'set_packing_category_assignees',
+    {
+      description: 'Assign trip members to a packing category.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        categoryName: z.string().min(1).max(100),
+        userIds: z.array(z.number().int().positive()),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, categoryName, userIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      updatePackingCategoryAssignees(tripId, categoryName, userIds);
+      safeBroadcast(tripId, 'packing:assignees', { categoryName, userIds });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'apply_packing_template',
+    {
+      description: 'Apply a packing template to a trip (adds items from the template).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        templateId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, templateId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const applied = applyTemplate(tripId, templateId);
+      if (applied === null) return { content: [{ type: 'text' as const, text: 'Template not found.' }], isError: true };
+      safeBroadcast(tripId, 'packing:template-applied', { templateId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'save_packing_template',
+    {
+      description: 'Save the current packing list as a reusable template.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        templateName: z.string().min(1).max(100),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, templateName }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      saveAsTemplate(tripId, userId, templateName);
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'bulk_import_packing',
+    {
+      description: 'Import multiple packing items at once from a list.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        items: z.array(z.object({
+          name: z.string().min(1).max(200),
+          category: z.string().optional(),
+          quantity: z.number().int().positive().optional(),
+        })).min(1),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, items }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      bulkImport(tripId, items);
+      safeBroadcast(tripId, 'packing:updated', {});
+      return ok({ success: true, count: items.length });
+    }
+  );
+}

server/src/mcp/tools/places.ts

@@ -0,0 +1,158 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import { listPlaces, createPlace, updatePlace, deletePlace } from '../../services/placeService';
+import { listCategories } from '../../services/categoryService';
+import { searchPlaces } from '../../services/mapsService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerPlaceTools(server: McpServer, userId: number): void {
+  // --- PLACES ---
+
+  server.registerTool(
+    'create_place',
+    {
+      description: 'Add a new place/POI to a trip. Set google_place_id or osm_id (from search_place) so the app can show opening hours and ratings.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        name: z.string().min(1).max(200),
+        description: z.string().max(2000).optional(),
+        lat: z.number().optional(),
+        lng: z.number().optional(),
+        address: z.string().max(500).optional(),
+        category_id: z.number().int().positive().optional().describe('Category ID — use list_categories to see available options'),
+        google_place_id: z.string().optional().describe('Google Place ID from search_place — enables opening hours display'),
+        osm_id: z.string().optional().describe('OpenStreetMap ID from search_place (e.g. "way:12345") — enables opening hours if no Google ID'),
+        notes: z.string().max(2000).optional(),
+        website: z.string().max(500).optional(),
+        phone: z.string().max(50).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, name, description, lat, lng, address, category_id, google_place_id, osm_id, notes, website, phone }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const place = createPlace(String(tripId), { name, description, lat, lng, address, category_id, google_place_id, osm_id, notes, website, phone });
+      safeBroadcast(tripId, 'place:created', { place });
+      return ok({ place });
+    }
+  );
+
+  server.registerTool(
+    'update_place',
+    {
+      description: 'Update an existing place in a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        placeId: z.number().int().positive(),
+        name: z.string().min(1).max(200).optional(),
+        description: z.string().max(2000).optional(),
+        lat: z.number().optional(),
+        lng: z.number().optional(),
+        address: z.string().max(500).optional(),
+        category_id: z.number().int().positive().optional().describe('Category ID — use list_categories'),
+        price: z.number().optional(),
+        currency: z.string().length(3).optional(),
+        place_time: z.string().max(50).optional().describe('Scheduled time (e.g. "09:00")'),
+        end_time: z.string().max(50).optional().describe('End time (e.g. "11:00")'),
+        duration_minutes: z.number().int().positive().optional(),
+        notes: z.string().max(2000).optional(),
+        website: z.string().max(500).optional(),
+        phone: z.string().max(50).optional(),
+        transport_mode: z.enum(['walking', 'driving', 'cycling', 'transit', 'flight']).optional(),
+        osm_id: z.string().optional().describe('OpenStreetMap ID (e.g. "way:12345")'),
+        google_place_id: z.string().optional().describe('Google Place ID (e.g. "ChIJd8BlQ2BZwokRAFUEcm_qrcA")'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, placeId, name, description, lat, lng, address, category_id, price, currency, place_time, end_time, duration_minutes, notes, website, phone, transport_mode, osm_id, google_place_id }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const place = updatePlace(String(tripId), String(placeId), { name, description, lat, lng, address, category_id, price, currency, place_time, end_time, duration_minutes, notes, website, phone, transport_mode, osm_id, google_place_id });
+      if (!place) return { content: [{ type: 'text' as const, text: 'Place not found.' }], isError: true };
+      safeBroadcast(tripId, 'place:updated', { place });
+      return ok({ place });
+    }
+  );
+
+  server.registerTool(
+    'delete_place',
+    {
+      description: 'Delete a place from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        placeId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, placeId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = deletePlace(String(tripId), String(placeId));
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Place not found.' }], isError: true };
+      safeBroadcast(tripId, 'place:deleted', { placeId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'list_places',
+    {
+      description: 'List all places/POIs in a trip, optionally filtered by assignment status. Use assignment=unassigned to find orphan activities not yet scheduled on any day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        search: z.string().optional(),
+        category: z.string().optional(),
+        tag: z.string().optional(),
+        assignment: z.enum(['all', 'unassigned', 'assigned']).optional().default('all').describe('Filter by assignment status: "all" (default), "unassigned" (not on any day), or "assigned" (scheduled on a day)'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId, search, category, tag, assignment }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const places = listPlaces(String(tripId), { search, category, tag, assignment });
+      return ok({ places });
+    }
+  );
+
+  // --- CATEGORIES ---
+
+  server.registerTool(
+    'list_categories',
+    {
+      description: 'List all available place categories with their id, name, icon and color. Use category_id when creating or updating places.',
+      inputSchema: {},
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async () => {
+      const categories = listCategories();
+      return ok({ categories });
+    }
+  );
+
+  // --- SEARCH ---
+
+  server.registerTool(
+    'search_place',
+    {
+      description: 'Search for a real-world place by name or address. Returns results with osm_id (and google_place_id if configured). Use these IDs when calling create_place so the app can display opening hours and ratings.',
+      inputSchema: {
+        query: z.string().min(1).max(500).describe('Place name or address to search for'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ query }) => {
+      try {
+        const result = await searchPlaces(userId, query);
+        return ok(result);
+      } catch {
+        return { content: [{ type: 'text' as const, text: 'Place search failed.' }], isError: true };
+      }
+    }
+  );
+}

server/src/mcp/tools/prompts.ts

@@ -0,0 +1,116 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { getTripSummary } from '../../services/tripService';
+import { listItems as listPackingItems } from '../../services/packingService';
+
+export function registerMcpPrompts(server: McpServer, _userId: number): void {
+  const userId = _userId;
+
+  server.registerPrompt(
+    'trip-summary',
+    {
+      title: 'Trip Summary',
+      description: 'Load a full summary of a trip for context before planning or modifications',
+      argsSchema: {
+        tripId: z.number().int().positive().describe('Trip ID to summarize'),
+      },
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'Trip not found or access denied.' } }] };
+      }
+      const summary = getTripSummary(tripId);
+      if (!summary) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'Trip not found.' } }] };
+      }
+      const { trip, days, members, budget, packing, reservations, collabNotes } = summary;
+      const packingStats = packing ? { total: packing.length, packed: packing.filter((p: any) => p.checked).length } : { total: 0, packed: 0 };
+      const budgetTotal = budget?.reduce((sum: number, b: any) => sum + (b.total_price || 0), 0) || 0;
+      const text = `Trip: ${trip?.title || 'Untitled'}${trip?.description ? `\n${trip.description}` : ''}
+Dates: ${trip?.start_date || '?'} to ${trip?.end_date || '?'}
+Members: ${members?.length || 0} (${members?.map((m: any) => m.name || m.email).join(', ') || 'none'})
+Days: ${days?.length || 0}
+Packing: ${packingStats.packed}/${packingStats.total} items packed
+Budget: ${budgetTotal} ${trip?.currency || 'EUR'} total
+Reservations: ${reservations?.length || 0}
+Collab Notes: ${collabNotes?.length || 0}
+${days?.map((d: any, i: number) => `Day ${i + 1} (${d.date}): ${d.assignments?.length || 0} places${d.title ? ` - ${d.title}` : ''}`).join('\n') || 'No days yet'}`;
+      return {
+        description: `Summary of trip "${trip?.title || tripId}"`,
+        messages: [{ role: 'user', content: { type: 'text', text } }],
+      };
+    }
+  );
+
+  server.registerPrompt(
+    'packing-list',
+    {
+      title: 'Packing List',
+      description: 'Get a formatted packing checklist for a trip',
+      argsSchema: {
+        tripId: z.number().int().positive().describe('Trip ID'),
+      },
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'Trip not found or access denied.' } }] };
+      }
+      const items = listPackingItems(tripId);
+      if (!items.length) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'No packing items found for this trip.' } }] };
+      }
+      const grouped = items.reduce((acc: Record<string, any[]>, item: any) => {
+        const cat = item.category || 'General';
+        if (!acc[cat]) acc[cat] = [];
+        acc[cat].push(item);
+        return acc;
+      }, {});
+      const lines = Object.entries(grouped).map(([cat, items]) =>
+        `## ${cat}\n${(items as any[]).map((i: any) => `- [${i.checked ? 'x' : ' '}] ${i.name}`).join('\n')}`
+      ).join('\n\n');
+      const { trip } = getTripSummary(tripId) || {};
+      return {
+        description: `Packing list for "${trip?.title || tripId}"`,
+        messages: [{ role: 'user', content: { type: 'text', text: `# Packing List: ${trip?.title || 'Trip'}\n\n${lines}\n\n_${items.length} items across ${Object.keys(grouped).length} categories_` } }],
+      };
+    }
+  );
+
+  server.registerPrompt(
+    'budget-overview',
+    {
+      title: 'Budget Overview',
+      description: 'Get a formatted budget summary for a trip',
+      argsSchema: {
+        tripId: z.number().int().positive().describe('Trip ID'),
+      },
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'Trip not found or access denied.' } }] };
+      }
+      const summary = getTripSummary(tripId);
+      if (!summary) {
+        return { messages: [{ role: 'user', content: { type: 'text', text: 'Trip not found.' } }] };
+      }
+      const { trip, budget } = summary;
+      const currency = trip?.currency || 'EUR';
+      const byCategory = (budget || []).reduce((acc: Record<string, number>, item: any) => {
+        const cat = item.category || 'Uncategorized';
+        acc[cat] = (acc[cat] || 0) + (item.total_price || 0);
+        return acc;
+      }, {} as Record<string, number>);
+      const total = Object.values(byCategory).reduce((s, v) => s + v, 0);
+      const lines = Object.entries(byCategory)
+        .sort(([, a], [, b]) => b - a)
+        .map(([cat, amount]) => `- ${cat}: ${amount} ${currency}`)
+        .join('\n');
+      const perPerson = (summary.members?.length || 1) > 0 ? (total / (summary.members?.length || 1)).toFixed(2) : total.toFixed(2);
+      return {
+        description: `Budget overview for "${trip?.title || tripId}"`,
+        messages: [{ role: 'user', content: { type: 'text', text: `# Budget: ${trip?.title || 'Trip'}\n\n**Total: ${total} ${currency}** (${perPerson} ${currency} per person)\n\n${lines || 'No expenses recorded.'}` } }],
+      };
+    }
+  );
+}

server/src/mcp/tools/reservations.ts

@@ -0,0 +1,203 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  createReservation, getReservation, updateReservation, deleteReservation,
+  updatePositions as updateReservationPositions,
+} from '../../services/reservationService';
+import { getDay } from '../../services/dayService';
+import { placeExists, getAssignmentForTrip } from '../../services/assignmentService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_WRITE, TOOL_ANNOTATIONS_DELETE,
+  TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerReservationTools(server: McpServer, userId: number): void {
+
+  server.registerTool(
+    'create_reservation',
+    {
+      description: 'Recommend a reservation for a trip. Created as pending — the user must confirm it. Linking: hotel → use place_id + start_day_id + end_day_id (all three required to create the accommodation link); restaurant/train/car/cruise/event/tour/activity/other → use assignment_id; flight → no linking.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        title: z.string().min(1).max(200),
+        type: z.enum(['flight', 'hotel', 'restaurant', 'train', 'car', 'cruise', 'event', 'tour', 'activity', 'other']).describe('Reservation type: "flight", "hotel", "restaurant", "train", "car", "cruise", "event", "tour", "activity", or "other"'),
+        reservation_time: z.string().optional().describe('ISO 8601 datetime or time string'),
+        location: z.string().max(500).optional(),
+        confirmation_number: z.string().max(100).optional(),
+        notes: z.string().max(1000).optional(),
+        day_id: z.number().int().positive().optional(),
+        place_id: z.number().int().positive().optional().describe('Hotel place to link (hotel type only)'),
+        start_day_id: z.number().int().positive().optional().describe('Check-in day (hotel type only; requires place_id and end_day_id)'),
+        end_day_id: z.number().int().positive().optional().describe('Check-out day (hotel type only; requires place_id and start_day_id)'),
+        check_in: z.string().max(10).optional().describe('Check-in time (e.g. "15:00", hotel type only)'),
+        check_out: z.string().max(10).optional().describe('Check-out time (e.g. "11:00", hotel type only)'),
+        assignment_id: z.number().int().positive().optional().describe('Link to a day assignment (restaurant, train, car, cruise, event, tour, activity, other)'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, title, type, reservation_time, location, confirmation_number, notes, day_id, place_id, start_day_id, end_day_id, check_in, check_out, assignment_id }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+
+      // Validate that all referenced IDs belong to this trip
+      if (day_id && !getDay(day_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'day_id does not belong to this trip.' }], isError: true };
+      if (place_id && !placeExists(place_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'place_id does not belong to this trip.' }], isError: true };
+      if (start_day_id && !getDay(start_day_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'start_day_id does not belong to this trip.' }], isError: true };
+      if (end_day_id && !getDay(end_day_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'end_day_id does not belong to this trip.' }], isError: true };
+      if (assignment_id && !getAssignmentForTrip(assignment_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'assignment_id does not belong to this trip.' }], isError: true };
+
+      const createAccommodation = (type === 'hotel' && place_id && start_day_id && end_day_id)
+        ? { place_id, start_day_id, end_day_id, check_in: check_in || undefined, check_out: check_out || undefined, confirmation: confirmation_number || undefined }
+        : undefined;
+
+      const { reservation, accommodationCreated } = createReservation(tripId, {
+        title, type, reservation_time, location, confirmation_number,
+        notes, day_id, place_id, assignment_id,
+        create_accommodation: createAccommodation,
+      });
+
+      if (accommodationCreated) {
+        safeBroadcast(tripId, 'accommodation:created', {});
+      }
+      safeBroadcast(tripId, 'reservation:created', { reservation });
+      return ok({ reservation });
+    }
+  );
+
+  server.registerTool(
+    'update_reservation',
+    {
+      description: 'Update an existing reservation in a trip. Use status "confirmed" to confirm a pending recommendation, or "pending" to revert it. Linking: hotel → use place_id to link to an accommodation place; restaurant/train/car/cruise/event/tour/activity/other → use assignment_id to link to a day assignment; flight → no linking.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        reservationId: z.number().int().positive(),
+        title: z.string().min(1).max(200).optional(),
+        type: z.enum(['flight', 'hotel', 'restaurant', 'train', 'car', 'cruise', 'event', 'tour', 'activity', 'other']).optional().describe('Reservation type: "flight", "hotel", "restaurant", "train", "car", "cruise", "event", "tour", "activity", or "other"'),
+        reservation_time: z.string().optional().describe('ISO 8601 datetime or time string'),
+        location: z.string().max(500).optional(),
+        confirmation_number: z.string().max(100).optional(),
+        notes: z.string().max(1000).optional(),
+        status: z.enum(['pending', 'confirmed', 'cancelled']).optional().describe('Reservation status: "pending", "confirmed", or "cancelled"'),
+        place_id: z.number().int().positive().nullable().optional().describe('Link to a place (use for hotel type), or null to unlink'),
+        assignment_id: z.number().int().positive().nullable().optional().describe('Link to a day assignment (use for restaurant, train, car, cruise, event, tour, activity, other), or null to unlink'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, reservationId, title, type, reservation_time, location, confirmation_number, notes, status, place_id, assignment_id }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const existing = getReservation(reservationId, tripId);
+      if (!existing) return { content: [{ type: 'text' as const, text: 'Reservation not found.' }], isError: true };
+
+      if (place_id != null && !placeExists(place_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'place_id does not belong to this trip.' }], isError: true };
+      if (assignment_id != null && !getAssignmentForTrip(assignment_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'assignment_id does not belong to this trip.' }], isError: true };
+
+      const { reservation } = updateReservation(reservationId, tripId, {
+        title, type, reservation_time, location, confirmation_number, notes, status,
+        place_id: place_id !== undefined ? place_id ?? undefined : undefined,
+        assignment_id: assignment_id !== undefined ? assignment_id ?? undefined : undefined,
+      }, existing);
+      safeBroadcast(tripId, 'reservation:updated', { reservation });
+      return ok({ reservation });
+    }
+  );
+
+  server.registerTool(
+    'delete_reservation',
+    {
+      description: 'Delete a reservation from a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        reservationId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, reservationId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const { deleted, accommodationDeleted } = deleteReservation(reservationId, tripId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'Reservation not found.' }], isError: true };
+      if (accommodationDeleted) {
+        safeBroadcast(tripId, 'accommodation:deleted', { accommodationId: deleted.accommodation_id });
+      }
+      safeBroadcast(tripId, 'reservation:deleted', { reservationId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'reorder_reservations',
+    {
+      description: 'Update the display order of reservations within a day.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        positions: z.array(z.object({
+          id: z.number().int().positive(),
+          day_plan_position: z.number().int().min(0),
+        })).describe('Array of { id, day_plan_position } pairs'),
+        dayId: z.number().int().positive().optional().describe('Optionally scope the update to a specific day'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, positions, dayId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      updateReservationPositions(tripId, positions, dayId);
+      safeBroadcast(tripId, 'reservation:positions', { positions, dayId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'link_hotel_accommodation',
+    {
+      description: 'Set or update the check-in/check-out day links for a hotel reservation. Creates or updates the accommodation record that ties the reservation to a place and a date range. Use the day IDs from get_trip_summary.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        reservationId: z.number().int().positive(),
+        place_id: z.number().int().positive().describe('The hotel place to link'),
+        start_day_id: z.number().int().positive().describe('Check-in day ID'),
+        end_day_id: z.number().int().positive().describe('Check-out day ID'),
+        check_in: z.string().max(10).optional().describe('Check-in time (e.g. "15:00")'),
+        check_out: z.string().max(10).optional().describe('Check-out time (e.g. "11:00")'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, reservationId, place_id, start_day_id, end_day_id, check_in, check_out }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const current = getReservation(reservationId, tripId);
+      if (!current) return { content: [{ type: 'text' as const, text: 'Reservation not found.' }], isError: true };
+      if (current.type !== 'hotel') return { content: [{ type: 'text' as const, text: 'Reservation is not of type hotel.' }], isError: true };
+
+      if (!placeExists(place_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'place_id does not belong to this trip.' }], isError: true };
+      if (!getDay(start_day_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'start_day_id does not belong to this trip.' }], isError: true };
+      if (!getDay(end_day_id, tripId))
+        return { content: [{ type: 'text' as const, text: 'end_day_id does not belong to this trip.' }], isError: true };
+
+      const isNewAccommodation = !current.accommodation_id;
+      const { reservation } = updateReservation(reservationId, tripId, {
+        place_id,
+        type: current.type,
+        status: current.status as string,
+        create_accommodation: { place_id, start_day_id, end_day_id, check_in: check_in || undefined, check_out: check_out || undefined },
+      }, current);
+
+      safeBroadcast(tripId, isNewAccommodation ? 'accommodation:created' : 'accommodation:updated', {});
+      safeBroadcast(tripId, 'reservation:updated', { reservation });
+      return ok({ reservation, accommodation_id: (reservation as any).accommodation_id });
+    }
+  );
+}

server/src/mcp/tools/tags.ts

@@ -0,0 +1,78 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { isDemoUser } from '../../services/authService';
+import { listTags, createTag, updateTag, deleteTag } from '../../services/tagService';
+import {
+  TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, ok,
+} from './_shared';
+
+export function registerTagTools(server: McpServer, userId: number): void {
+  // --- TAGS ---
+
+  server.registerTool(
+    'list_tags',
+    {
+      description: 'List all tags belonging to the current user.',
+      inputSchema: {},
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async () => {
+      const tags = listTags(userId);
+      return ok({ tags });
+    }
+  );
+
+  server.registerTool(
+    'create_tag',
+    {
+      description: 'Create a new tag (user-scoped label for places).',
+      inputSchema: {
+        name: z.string().min(1).max(100),
+        color: z.string().optional().describe('Hex color string e.g. #6366f1'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ name, color }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const tag = createTag(userId, name, color);
+      return ok({ tag });
+    }
+  );
+
+  server.registerTool(
+    'update_tag',
+    {
+      description: 'Update the name or color of an existing tag.',
+      inputSchema: {
+        tagId: z.number().int().positive(),
+        name: z.string().optional(),
+        color: z.string().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tagId, name, color }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      const tag = updateTag(tagId, name, color);
+      if (!tag) return { content: [{ type: 'text' as const, text: 'Tag not found.' }], isError: true };
+      return ok({ tag });
+    }
+  );
+
+  server.registerTool(
+    'delete_tag',
+    {
+      description: 'Delete a tag (removes it from all places it was attached to).',
+      inputSchema: {
+        tagId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tagId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      deleteTag(tagId);
+      return ok({ success: true });
+    }
+  );
+}

server/src/mcp/tools/todos.ts

@@ -0,0 +1,185 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  listItems as listTodoItems, createItem as createTodoItem, updateItem as updateTodoItem,
+  deleteItem as deleteTodoItem, reorderItems as reorderTodoItems,
+  getCategoryAssignees as getTodoCategoryAssignees, updateCategoryAssignees as updateTodoCategoryAssignees,
+} from '../../services/todoService';
+import {
+  safeBroadcast, TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerTodoTools(server: McpServer, userId: number): void {
+  // --- TODOS ---
+
+  server.registerTool(
+    'list_todos',
+    {
+      description: 'List all to-do items for a trip, ordered by position.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const items = listTodoItems(tripId);
+      return ok({ items });
+    }
+  );
+
+  server.registerTool(
+    'create_todo',
+    {
+      description: 'Create a new to-do item for a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        name: z.string().min(1).max(500).describe('To-do item name'),
+        category: z.string().max(100).optional().describe('Category (e.g. "Logistics", "Booking")'),
+        due_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Due date (YYYY-MM-DD)'),
+        description: z.string().max(2000).optional().describe('Additional description'),
+        assigned_user_id: z.number().int().positive().optional().describe('User ID to assign this task to'),
+        priority: z.number().int().min(0).max(3).optional().describe('Priority: 0=none, 1=low, 2=medium, 3=high'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, name, category, due_date, description, assigned_user_id, priority }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = createTodoItem(tripId, { name, category, due_date, description, assigned_user_id, priority });
+      safeBroadcast(tripId, 'todo:created', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'update_todo',
+    {
+      description: 'Update an existing to-do item. Only provided fields are changed; omitted fields stay as-is. Pass null to clear a nullable field.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        name: z.string().min(1).max(500).optional(),
+        category: z.string().max(100).optional(),
+        due_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional().describe('Set to null to clear the due date'),
+        description: z.string().max(2000).nullable().optional().describe('Set to null to clear'),
+        assigned_user_id: z.number().int().positive().nullable().optional().describe('Set to null to unassign'),
+        priority: z.number().int().min(0).max(3).nullable().optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, name, category, due_date, description, assigned_user_id, priority }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      // Build bodyKeys to signal which nullable fields were explicitly provided
+      const bodyKeys: string[] = [];
+      if (due_date !== undefined) bodyKeys.push('due_date');
+      if (description !== undefined) bodyKeys.push('description');
+      if (assigned_user_id !== undefined) bodyKeys.push('assigned_user_id');
+      if (priority !== undefined) bodyKeys.push('priority');
+      const item = updateTodoItem(tripId, itemId, { name, category, due_date, description, assigned_user_id, priority }, bodyKeys);
+      if (!item) return { content: [{ type: 'text' as const, text: 'To-do item not found.' }], isError: true };
+      safeBroadcast(tripId, 'todo:updated', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'toggle_todo',
+    {
+      description: 'Mark a to-do item as checked (done) or unchecked.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+        checked: z.boolean().describe('True to mark done, false to uncheck'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, itemId, checked }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const item = updateTodoItem(tripId, itemId, { checked: checked ? 1 : 0 }, []);
+      if (!item) return { content: [{ type: 'text' as const, text: 'To-do item not found.' }], isError: true };
+      safeBroadcast(tripId, 'todo:updated', { item });
+      return ok({ item });
+    }
+  );
+
+  server.registerTool(
+    'delete_todo',
+    {
+      description: 'Delete a to-do item.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        itemId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, itemId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const deleted = deleteTodoItem(tripId, itemId);
+      if (!deleted) return { content: [{ type: 'text' as const, text: 'To-do item not found.' }], isError: true };
+      safeBroadcast(tripId, 'todo:deleted', { itemId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'reorder_todos',
+    {
+      description: 'Reorder to-do items within a trip by providing a new ordered list of item IDs.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        orderedIds: z.array(z.number().int().positive()).min(1).describe('All item IDs in the desired order'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, orderedIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      reorderTodoItems(tripId, orderedIds);
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'get_todo_category_assignees',
+    {
+      description: 'Get the default assignees configured per to-do category for a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const assignees = getTodoCategoryAssignees(tripId);
+      return ok({ assignees });
+    }
+  );
+
+  server.registerTool(
+    'set_todo_category_assignees',
+    {
+      description: 'Set the default assignees for a to-do category on a trip. Pass an empty array to clear.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        categoryName: z.string().min(1).max(100).describe('Category name'),
+        userIds: z.array(z.number().int().positive()).describe('User IDs to assign as defaults for this category'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, categoryName, userIds }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const assignees = updateTodoCategoryAssignees(tripId, categoryName, userIds);
+      safeBroadcast(tripId, 'todo:assignees', { category: categoryName, assignees });
+      return ok({ assignees });
+    }
+  );
+}

server/src/mcp/tools/trips.ts

@@ -0,0 +1,338 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { canAccessTrip } from '../../db/database';
+import { isDemoUser } from '../../services/authService';
+import {
+  listTrips, createTrip, updateTrip, deleteTrip, getTripSummary,
+  isOwner, verifyTripAccess,
+  listMembers as listTripMembers, getTripOwner, addMember as addTripMember,
+  removeMember as removeTripMember,
+  copyTripById, exportICS, NotFoundError, ValidationError,
+} from '../../services/tripService';
+import {
+  createOrUpdateShareLink, getShareLink, deleteShareLink,
+} from '../../services/shareService';
+import { isAddonEnabled } from '../../services/adminService';
+import { countMessages, listPolls } from '../../services/collabService';
+import {
+  listItems as listTodoItems,
+} from '../../services/todoService';
+import { listFiles } from '../../services/fileService';
+import {
+  safeBroadcast, MAX_MCP_TRIP_DAYS,
+  TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, noAccess, ok,
+} from './_shared';
+
+export function registerTripTools(server: McpServer, userId: number): void {
+  // --- TRIPS ---
+
+  server.registerTool(
+    'create_trip',
+    {
+      description: 'Create a new trip. Returns the created trip with its generated days.',
+      inputSchema: {
+        title: z.string().min(1).max(200).describe('Trip title'),
+        description: z.string().max(2000).optional().describe('Trip description'),
+        start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('Start date (YYYY-MM-DD)'),
+        end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe('End date (YYYY-MM-DD)'),
+        currency: z.string().length(3).optional().describe('Currency code (e.g. EUR, USD)'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ title, description, start_date, end_date, currency }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (start_date) {
+        const d = new Date(start_date + 'T00:00:00Z');
+        if (isNaN(d.getTime()) || d.toISOString().slice(0, 10) !== start_date)
+          return { content: [{ type: 'text' as const, text: 'start_date is not a valid calendar date.' }], isError: true };
+      }
+      if (end_date) {
+        const d = new Date(end_date + 'T00:00:00Z');
+        if (isNaN(d.getTime()) || d.toISOString().slice(0, 10) !== end_date)
+          return { content: [{ type: 'text' as const, text: 'end_date is not a valid calendar date.' }], isError: true };
+      }
+      if (start_date && end_date && new Date(end_date) < new Date(start_date)) {
+        return { content: [{ type: 'text' as const, text: 'End date must be after start date.' }], isError: true };
+      }
+      const { trip } = createTrip(userId, { title, description, start_date, end_date, currency }, MAX_MCP_TRIP_DAYS);
+      return ok({ trip });
+    }
+  );
+
+  server.registerTool(
+    'update_trip',
+    {
+      description: 'Update an existing trip\'s details.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        title: z.string().min(1).max(200).optional(),
+        description: z.string().max(2000).optional(),
+        start_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+        end_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+        currency: z.string().length(3).optional(),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, title, description, start_date, end_date, currency }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      if (start_date) {
+        const d = new Date(start_date + 'T00:00:00Z');
+        if (isNaN(d.getTime()) || d.toISOString().slice(0, 10) !== start_date)
+          return { content: [{ type: 'text' as const, text: 'start_date is not a valid calendar date.' }], isError: true };
+      }
+      if (end_date) {
+        const d = new Date(end_date + 'T00:00:00Z');
+        if (isNaN(d.getTime()) || d.toISOString().slice(0, 10) !== end_date)
+          return { content: [{ type: 'text' as const, text: 'end_date is not a valid calendar date.' }], isError: true };
+      }
+      const { updatedTrip } = updateTrip(tripId, userId, { title, description, start_date, end_date, currency }, 'user');
+      safeBroadcast(tripId, 'trip:updated', { trip: updatedTrip });
+      return ok({ trip: updatedTrip });
+    }
+  );
+
+  server.registerTool(
+    'delete_trip',
+    {
+      description: 'Delete a trip. Only the trip owner can delete it.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!isOwner(tripId, userId)) return noAccess();
+      deleteTrip(tripId, userId, 'user');
+      return ok({ success: true, tripId });
+    }
+  );
+
+  server.registerTool(
+    'list_trips',
+    {
+      description: 'List all trips the current user owns or is a member of. Use this for trip discovery before calling get_trip_summary.',
+      inputSchema: {
+        include_archived: z.boolean().optional().describe('Include archived trips (default false)'),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ include_archived }) => {
+      const trips = listTrips(userId, include_archived ? null : 0);
+      return ok({ trips });
+    }
+  );
+
+  // --- TRIP SUMMARY ---
+
+  server.registerTool(
+    'get_trip_summary',
+    {
+      description: 'Get a full denormalized summary of a trip in a single call: metadata, members, days with assignments and notes, accommodations, budget totals, packing stats, reservations, and collab notes. Use this as a context loader before planning or modifying a trip.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const summary = getTripSummary(tripId);
+      if (!summary) return noAccess();
+      const todos = listTodoItems(tripId);
+      const files = listFiles(tripId, false).map((f: any) => ({
+        id: f.id,
+        original_name: f.original_name,
+        mime_type: f.mime_type,
+        file_size: f.file_size,
+        starred: !!f.starred,
+        deleted: !!f.deleted_at,
+        created_at: f.created_at,
+      }));
+      let pollCount = 0;
+      if (isAddonEnabled('collab')) {
+        pollCount = listPolls(tripId).length;
+      }
+      let messageCount = 0;
+      if (isAddonEnabled('collab')) {
+        messageCount = countMessages(tripId);
+      }
+      return ok({ ...summary, todos, files, pollCount, messageCount });
+    }
+  );
+
+  // --- TRIP MEMBERS, COPY, ICS, SHARE ---
+
+  server.registerTool(
+    'list_trip_members',
+    {
+      description: 'List all members of a trip (owner + collaborators).',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const ownerRow = getTripOwner(tripId);
+      if (!ownerRow) return noAccess();
+      const { owner, members } = listTripMembers(tripId, ownerRow.user_id);
+      return ok({ owner, members });
+    }
+  );
+
+  server.registerTool(
+    'add_trip_member',
+    {
+      description: 'Add a user to a trip by their username or email address. Only the trip owner can do this.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        identifier: z.string().min(1).describe('Username or email of the user to add'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, identifier }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const ownerRow = getTripOwner(tripId);
+      if (!ownerRow || ownerRow.user_id !== userId)
+        return { content: [{ type: 'text' as const, text: 'Only the trip owner can add members.' }], isError: true };
+      try {
+        const result = addTripMember(tripId, identifier, ownerRow.user_id, userId);
+        safeBroadcast(tripId, 'member:added', { member: result.member });
+        return ok({ member: result.member });
+      } catch (err) {
+        const msg = err instanceof ValidationError || err instanceof NotFoundError ? err.message : 'Failed to add member.';
+        return { content: [{ type: 'text' as const, text: msg }], isError: true };
+      }
+    }
+  );
+
+  server.registerTool(
+    'remove_trip_member',
+    {
+      description: 'Remove a member from a trip. Only the trip owner can do this.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        memberId: z.number().int().positive().describe('User ID of the member to remove'),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId, memberId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const ownerRow = getTripOwner(tripId);
+      if (!ownerRow || ownerRow.user_id !== userId)
+        return { content: [{ type: 'text' as const, text: 'Only the trip owner can remove members.' }], isError: true };
+      removeTripMember(tripId, memberId);
+      safeBroadcast(tripId, 'member:removed', { userId: memberId });
+      return ok({ success: true });
+    }
+  );
+
+  server.registerTool(
+    'copy_trip',
+    {
+      description: 'Duplicate a trip (all days, places, itinerary, packing, budget, reservations, day notes). Packing items are reset to unchecked. Returns the new trip.',
+      inputSchema: {
+        tripId: z.number().int().positive().describe('Source trip ID to duplicate'),
+        title: z.string().min(1).max(200).optional().describe('Title for the new trip (defaults to source title)'),
+      },
+      annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+    },
+    async ({ tripId, title }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      try {
+        const newTripId = copyTripById(tripId, userId, title);
+        const newTrip = canAccessTrip(newTripId, userId);
+        return ok({ trip: { id: newTripId, ...newTrip } });
+      } catch {
+        return { content: [{ type: 'text' as const, text: 'Failed to copy trip.' }], isError: true };
+      }
+    }
+  );
+
+  server.registerTool(
+    'export_trip_ics',
+    {
+      description: 'Export a trip\'s itinerary and reservations as iCalendar (.ics) format text. Useful for importing into calendar apps.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      try {
+        const { ics, filename } = exportICS(tripId);
+        return ok({ ics, filename });
+      } catch {
+        return { content: [{ type: 'text' as const, text: 'Trip not found.' }], isError: true };
+      }
+    }
+  );
+
+  server.registerTool(
+    'get_share_link',
+    {
+      description: 'Get the current public share link for a trip, including its permission flags. Returns null if no share link exists.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_READONLY,
+    },
+    async ({ tripId }) => {
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const link = getShareLink(String(tripId));
+      return ok({ link });
+    }
+  );
+
+  server.registerTool(
+    'create_share_link',
+    {
+      description: 'Create or update the public share link for a trip. Set permission flags to control what is visible to guests.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+        share_map: z.boolean().optional().default(true).describe('Share the map and places'),
+        share_bookings: z.boolean().optional().default(true).describe('Share reservations'),
+        share_packing: z.boolean().optional().default(false).describe('Share packing list'),
+        share_budget: z.boolean().optional().default(false).describe('Share budget'),
+        share_collab: z.boolean().optional().default(false).describe('Share collab messages'),
+      },
+      annotations: TOOL_ANNOTATIONS_WRITE,
+    },
+    async ({ tripId, share_map, share_bookings, share_packing, share_budget, share_collab }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      const { token, created } = createOrUpdateShareLink(String(tripId), userId, {
+        share_map: share_map ?? true,
+        share_bookings: share_bookings ?? true,
+        share_packing: share_packing ?? false,
+        share_budget: share_budget ?? false,
+        share_collab: share_collab ?? false,
+      });
+      return ok({ token, created });
+    }
+  );
+
+  server.registerTool(
+    'delete_share_link',
+    {
+      description: 'Revoke the public share link for a trip. Guests will no longer be able to access the shared view.',
+      inputSchema: {
+        tripId: z.number().int().positive(),
+      },
+      annotations: TOOL_ANNOTATIONS_DELETE,
+    },
+    async ({ tripId }) => {
+      if (isDemoUser(userId)) return demoDenied();
+      if (!canAccessTrip(tripId, userId)) return noAccess();
+      deleteShareLink(String(tripId));
+      return ok({ success: true });
+    }
+  );
+}

server/src/mcp/tools/vacay.ts

@@ -0,0 +1,393 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { z } from 'zod';
+import { isDemoUser, getCurrentUser } from '../../services/authService';
+import {
+  getOwnPlan, getActivePlan, getActivePlanId, getPlanData,
+  updatePlan, setUserColor,
+  sendInvite as sendVacayInvite, acceptInvite, declineInvite, cancelInvite, dissolvePlan,
+  getAvailableUsers,
+  listYears, addYear, deleteYear,
+  getEntries as getVacayEntries, toggleEntry, toggleCompanyHoliday,
+  getStats as getVacayStats, updateStats as updateVacayStats,
+  addHolidayCalendar, updateHolidayCalendar, deleteHolidayCalendar,
+  getCountries as getHolidayCountries, getHolidays,
+} from '../../services/vacayService';
+import { isAddonEnabled } from '../../services/adminService';
+import {
+  TOOL_ANNOTATIONS_READONLY, TOOL_ANNOTATIONS_WRITE,
+  TOOL_ANNOTATIONS_DELETE, TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+  demoDenied, ok,
+} from './_shared';
+
+export function registerVacayTools(server: McpServer, userId: number): void {
+  if (isAddonEnabled('vacay')) {
+    server.registerTool(
+      'get_vacay_plan',
+      {
+        description: "Get the current user's active vacation plan (own or joined).",
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const plan = getPlanData(userId);
+        return ok({ plan });
+      }
+    );
+
+    server.registerTool(
+      'update_vacay_plan',
+      {
+        description: 'Update vacation plan settings (weekends blocking, holidays, carry-over).',
+        inputSchema: {
+          block_weekends: z.boolean().optional(),
+          holidays_enabled: z.boolean().optional(),
+          holidays_region: z.string().nullable().optional(),
+          company_holidays_enabled: z.boolean().optional(),
+          carry_over_enabled: z.boolean().optional(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ block_weekends, holidays_enabled, holidays_region, company_holidays_enabled, carry_over_enabled }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        await updatePlan(planId, { block_weekends, holidays_enabled, holidays_region, company_holidays_enabled, carry_over_enabled }, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'set_vacay_color',
+      {
+        description: "Set the current user's color in the vacation plan calendar.",
+        inputSchema: {
+          color: z.string().describe('Hex color e.g. #6366f1'),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ color }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        setUserColor(userId, planId, color, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'get_available_vacay_users',
+      {
+        description: 'List users who can be invited to the current vacation plan.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const planId = getActivePlanId(userId);
+        const users = getAvailableUsers(userId, planId);
+        return ok({ users });
+      }
+    );
+
+    server.registerTool(
+      'send_vacay_invite',
+      {
+        description: 'Invite a user to join the vacation plan by their user ID.',
+        inputSchema: {
+          targetUserId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ targetUserId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const me = getCurrentUser(userId);
+        if (!me) return { content: [{ type: 'text' as const, text: 'User not found.' }], isError: true };
+        const result = sendVacayInvite(planId, userId, me.username, me.email, targetUserId);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'accept_vacay_invite',
+      {
+        description: 'Accept a pending invitation to join another user\'s vacation plan.',
+        inputSchema: {
+          planId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ planId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const result = acceptInvite(userId, planId, undefined);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'decline_vacay_invite',
+      {
+        description: 'Decline a pending vacation plan invitation.',
+        inputSchema: {
+          planId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ planId }) => {
+        declineInvite(userId, planId, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'cancel_vacay_invite',
+      {
+        description: 'Cancel an outgoing invitation (owner cancels invite they sent).',
+        inputSchema: {
+          targetUserId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ targetUserId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        cancelInvite(planId, targetUserId);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'dissolve_vacay_plan',
+      {
+        description: 'Dissolve the shared plan — all members are removed and everyone returns to their own individual plan.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async () => {
+        if (isDemoUser(userId)) return demoDenied();
+        dissolvePlan(userId, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'list_vacay_years',
+      {
+        description: 'List calendar years tracked in the current vacation plan.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const planId = getActivePlanId(userId);
+        const years = listYears(planId);
+        return ok({ years });
+      }
+    );
+
+    server.registerTool(
+      'add_vacay_year',
+      {
+        description: 'Add a calendar year to the vacation plan.',
+        inputSchema: {
+          year: z.number().int().min(2000).max(2100),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ year }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const years = addYear(planId, year, undefined);
+        return ok({ years });
+      }
+    );
+
+    server.registerTool(
+      'delete_vacay_year',
+      {
+        description: 'Remove a calendar year from the vacation plan.',
+        inputSchema: {
+          year: z.number().int(),
+        },
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async ({ year }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const years = deleteYear(planId, year, undefined);
+        return ok({ years });
+      }
+    );
+
+    server.registerTool(
+      'get_vacay_entries',
+      {
+        description: 'Get all vacation day entries for a plan and year.',
+        inputSchema: {
+          year: z.number().int(),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ year }) => {
+        const planId = getActivePlanId(userId);
+        const entries = getVacayEntries(planId, String(year));
+        return ok({ entries });
+      }
+    );
+
+    server.registerTool(
+      'toggle_vacay_entry',
+      {
+        description: 'Toggle a day on or off as a vacation day for the current user.',
+        inputSchema: {
+          date: z.string().describe('ISO date YYYY-MM-DD'),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ date }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const result = toggleEntry(userId, planId, date, undefined);
+        return ok(result);
+      }
+    );
+
+    server.registerTool(
+      'toggle_company_holiday',
+      {
+        description: 'Toggle a date as a company holiday for the whole plan.',
+        inputSchema: {
+          date: z.string(),
+          note: z.string().optional(),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ date, note }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const result = toggleCompanyHoliday(planId, date, note, undefined);
+        return ok(result);
+      }
+    );
+
+    server.registerTool(
+      'get_vacay_stats',
+      {
+        description: 'Get vacation statistics for a specific year (days used, remaining, carried over).',
+        inputSchema: {
+          year: z.number().int(),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ year }) => {
+        const planId = getActivePlanId(userId);
+        const stats = getVacayStats(planId, year);
+        return ok({ stats });
+      }
+    );
+
+    server.registerTool(
+      'update_vacay_stats',
+      {
+        description: 'Update the vacation day allowance for a specific user and year.',
+        inputSchema: {
+          year: z.number().int(),
+          vacationDays: z.number().int().min(0),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ year, vacationDays }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        updateVacayStats(userId, planId, year, vacationDays, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'add_holiday_calendar',
+      {
+        description: 'Add a public holiday calendar (by region code) to the vacation plan.',
+        inputSchema: {
+          region: z.string().describe('Country/region code e.g. US, GB, DE'),
+          label: z.string().nullable().optional(),
+          color: z.string().optional(),
+          sortOrder: z.number().int().optional(),
+        },
+        annotations: TOOL_ANNOTATIONS_NON_IDEMPOTENT,
+      },
+      async ({ region, label, color, sortOrder }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const calendar = addHolidayCalendar(planId, region, label ?? null, color, sortOrder, undefined);
+        return ok({ calendar });
+      }
+    );
+
+    server.registerTool(
+      'update_holiday_calendar',
+      {
+        description: 'Update label or color for a holiday calendar.',
+        inputSchema: {
+          calendarId: z.number().int().positive(),
+          label: z.string().nullable().optional(),
+          color: z.string().optional(),
+        },
+        annotations: TOOL_ANNOTATIONS_WRITE,
+      },
+      async ({ calendarId, label, color }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        const cal = updateHolidayCalendar(calendarId, planId, { label, color }, undefined);
+        if (!cal) return { content: [{ type: 'text' as const, text: 'Holiday calendar not found.' }], isError: true };
+        return ok({ calendar: cal });
+      }
+    );
+
+    server.registerTool(
+      'delete_holiday_calendar',
+      {
+        description: 'Remove a holiday calendar from the vacation plan.',
+        inputSchema: {
+          calendarId: z.number().int().positive(),
+        },
+        annotations: TOOL_ANNOTATIONS_DELETE,
+      },
+      async ({ calendarId }) => {
+        if (isDemoUser(userId)) return demoDenied();
+        const planId = getActivePlanId(userId);
+        deleteHolidayCalendar(calendarId, planId, undefined);
+        return ok({ success: true });
+      }
+    );
+
+    server.registerTool(
+      'list_holiday_countries',
+      {
+        description: 'List countries available for public holiday calendars.',
+        inputSchema: {},
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async () => {
+        const result = await getHolidayCountries();
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        return ok({ countries: result.data });
+      }
+    );
+
+    server.registerTool(
+      'list_holidays',
+      {
+        description: 'List public holidays for a country and year.',
+        inputSchema: {
+          country: z.string().describe('ISO 3166-1 alpha-2 code'),
+          year: z.number().int(),
+        },
+        annotations: TOOL_ANNOTATIONS_READONLY,
+      },
+      async ({ country, year }) => {
+        const result = await getHolidays(String(year), country);
+        if (result.error) return { content: [{ type: 'text' as const, text: result.error }], isError: true };
+        return ok({ holidays: result.data });
+      }
+    );
+  }
+}