@mgsoftwarebv/mcp-server-bridge 3.3.3 → 3.3.5

package/dist/index.js

@@ -93101,6 +93101,9 @@ var tickets = pgTable(
       precision: 10,
       scale: 2
     }).default(0),
+    // Deadline / due date - shown as a virtual "deadline" event in the agenda
+    dueDate: timestamp("due_date", { withTimezone: true, mode: "string" }),
+    dueDateAllDay: boolean3("due_date_all_day").notNull().default(false),
     // Origin tracking - how the ticket was created
     origin: ticketOriginEnum().default("manual").notNull(),
     // Structured context (e.g. visual review anchor metadata)
@@ -93177,6 +93180,7 @@ var tickets = pgTable(
     index("idx_tickets_status").on(table.status),
     index("idx_tickets_priority").on(table.priority),
     index("idx_tickets_created_at").using("btree", table.createdAt.desc()),
+    index("idx_tickets_due_date").on(table.teamId, table.dueDate),
     index("idx_tickets_fts").using(
       "gin",
       table.fts.asc().nullsLast().op("tsvector_ops")
@@ -95053,6 +95057,15 @@ var quotations = pgTable(
     topBlock: jsonb("top_block"),
     bottomBlock: jsonb("bottom_block"),
     template: jsonb(),
+    // Typst block-document content (mirrors `documents.blocks`). The pricing
+    // block is the financial source of truth; line_items/amount/subtotal/vat
+    // are derived from it on save for invoicing/KPIs/AI.
+    blocks: jsonb().default([]).notNull(),
+    branding: jsonb().default({}).notNull(),
+    pageSize: text("page_size").default("a4").notNull(),
+    // PDF staleness marker: hash of the compiled block content + file size.
+    compiledHash: text("compiled_hash"),
+    fileSize: integer2("file_size"),
     vat: numericCasted({ precision: 10, scale: 2 }),
     tax: numericCasted({ precision: 10, scale: 2 }),
     discount: numericCasted({ precision: 10, scale: 2 }),
@@ -105507,7 +105520,7 @@ var TOOLS = [
   },
   {
     name: "get-tickets",
-    description: "Get tickets with optional filtering by status, priority, project, customer, or search query",
+    description: "Get tickets with optional filtering by status, priority, project, customer, tags, or search query. Each ticket includes its tags.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105533,6 +105546,20 @@ var TOOLS = [
           type: "string",
           description: "Search query for ticket number, title, or description"
         },
+        tag: {
+          type: "string",
+          description: "Filter by a single tag name (case-insensitive, team-specific)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by tag names (case-insensitive). Tickets matching any listed tag are returned."
+        },
+        tagIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by tag IDs"
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -105540,7 +105567,7 @@ var TOOLS = [
   },
   {
     name: "get-ticket-by-id",
-    description: "Get a specific ticket by its ID, including comment text and a full attachment listing (with ids). Images from ticket and comment attachments are downloaded and returned inline as base64. For non-image attachments, call get-ticket-attachment with the listed id to get a download URL.",
+    description: "Get a specific ticket by its ID, including tags, comment text and a full attachment listing (with ids). Images from ticket and comment attachments are downloaded and returned inline as base64. For non-image attachments, call get-ticket-attachment with the listed id to get a download URL.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105552,7 +105579,7 @@ var TOOLS = [
   },
   {
     name: "create-ticket",
-    description: "Create a new ticket",
+    description: "Create a new ticket. Tags can be passed by name (auto-created if missing) or by existing tag IDs. Tag names are matched case-insensitively within the team.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105589,14 +105616,28 @@ var TOOLS = [
           default: "task"
         },
         projectId: { type: "string" },
-        customerId: { type: "string" }
+        customerId: { type: "string" },
+        dueDate: {
+          type: "string",
+          description: "Optional deadline / due date (ISO 8601, e.g. 2026-06-30). Shows as a deadline event in the agenda."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag names to attach. Missing tags are created as general team tags (case-insensitive deduplication)."
+        },
+        tagIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Existing tag IDs to attach"
+        }
       },
       required: ["title"]
     }
   },
   {
     name: "update-ticket",
-    description: "Update an existing ticket's fields (title, description, status, priority, type, project, customer, assignee, estimated hours). Only provided fields are changed. Changes are written to the ticket activity feed but do NOT send notifications. Set assigneeId to null to unassign; a provided assigneeId must be a member of the ticket's team. Common workflow: set status=in_progress when starting work; after merge/push set status=review and assigneeId to the requester (creator) id from get-ticket-by-id.",
+    description: "Update an existing ticket's fields (title, description, status, priority, type, project, customer, assignee, estimated hours, deadline/due date, tags). Only provided fields are changed. Changes are written to the ticket activity feed but do NOT send notifications. Set assigneeId to null to unassign; a provided assigneeId must be a member of the ticket's team. Set dueDate (ISO 8601, e.g. 2026-06-30 or 2026-06-30T00:00:00.000Z) to give the ticket a deadline that shows up in the agenda; set dueDate to null to clear it. Tags: use tagMode replace (default) to set the full tag list, merge to add tags, or remove to drop listed tags. Common workflow: set status=in_progress when starting work; after merge/push set status=review and assigneeId to the requester (creator) id from get-ticket-by-id.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105639,7 +105680,159 @@ var TOOLS = [
           type: ["string", "null"],
           description: "User ID to assign, or null to unassign."
         },
-        estimatedHours: { type: "number" }
+        estimatedHours: { type: "number" },
+        dueDate: {
+          type: ["string", "null"],
+          description: "Deadline / due date (ISO 8601, e.g. 2026-06-30 or 2026-06-30T00:00:00.000Z). Shows as a deadline event in the agenda. Pass null to clear the deadline."
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag names. With tagMode replace (default), sets the ticket's tags. With merge, adds tags. With remove, removes these tags. Missing names are auto-created when adding."
+        },
+        tagIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag IDs (same tagMode semantics as tags)"
+        },
+        tagMode: {
+          type: "string",
+          enum: ["replace", "merge", "remove"],
+          default: "replace",
+          description: "How to apply tags/tagIds: replace = set full list, merge = add, remove = remove listed tags"
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "get-tags",
+    description: "List tags for the provider team. Tags are team-specific; optional projectId includes general tags plus project-specific tags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        projectId: {
+          type: "string",
+          description: "Optional project ID to include project-specific tags"
+        },
+        pageSize: { type: "number", default: 100, maximum: 200 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create-tag",
+    description: "Create a team tag. Tag names are deduplicated case-insensitively within the same team/project scope.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        name: { type: "string", description: "Tag name" },
+        projectId: {
+          type: "string",
+          description: "Optional project ID for a project-specific tag; omit for a general team tag"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "get-calendar-items",
+    description: "List agenda/calendar items (deadlines, meetings, reminders, deliveries) with optional filters by date range, project, ticket, customer, assignee, type, or status. Returns items with id, title, startsAt, endsAt, dueDate, linked ticket/project/customer ids, and status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        projectId: { type: "string" },
+        ticketId: { type: "string" },
+        customerId: { type: "string" },
+        assigneeId: { type: "string" },
+        dateFrom: {
+          type: "string",
+          description: "ISO datetime or YYYY-MM-DD (inclusive start)"
+        },
+        dateTo: {
+          type: "string",
+          description: "ISO datetime or YYYY-MM-DD (inclusive end)"
+        },
+        status: {
+          type: "string",
+          enum: ["draft", "scheduled", "completed", "cancelled"]
+        },
+        type: {
+          type: "string",
+          enum: ["deadline", "meeting", "reminder", "delivery"]
+        },
+        pageSize: { type: "number", default: 50, maximum: 100 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create-calendar-item",
+    description: "Create an agenda/calendar item linked to tickets, projects, or customers. Use type 'deadline' with dueDate (YYYY-MM-DD) for delivery deadlines. Prevents duplicate deadline items for the same ticket \u2014 updates the existing one instead. Types: deadline, meeting, reminder, delivery.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        title: { type: "string" },
+        description: { type: "string" },
+        dueDate: {
+          type: "string",
+          description: "Deadline date YYYY-MM-DD (all-day). Preferred for deadlines."
+        },
+        startsAt: {
+          type: "string",
+          description: "Start datetime (ISO). Use when a specific time is needed."
+        },
+        endsAt: { type: "string", description: "End datetime (ISO)" },
+        projectId: { type: "string" },
+        ticketId: { type: "string" },
+        customerId: { type: "string" },
+        assigneeId: {
+          type: "string",
+          description: "User ID of the assignee (defaults to the API key user)"
+        },
+        type: {
+          type: "string",
+          enum: ["deadline", "meeting", "reminder", "delivery"],
+          default: "deadline"
+        },
+        status: {
+          type: "string",
+          enum: ["draft", "scheduled", "completed"],
+          default: "scheduled"
+        }
+      },
+      required: ["title"]
+    }
+  },
+  {
+    name: "update-calendar-item",
+    description: "Update an existing agenda/calendar item by id. Supports changing title, dates, status, type, and linked ticket/project/customer. Set status to 'completed' or 'cancelled' to finish or remove the item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        id: { type: "string", description: "Calendar item ID" },
+        title: { type: "string" },
+        description: { type: ["string", "null"] },
+        dueDate: { type: "string", description: "YYYY-MM-DD" },
+        startsAt: { type: "string" },
+        endsAt: { type: "string" },
+        projectId: { type: ["string", "null"] },
+        ticketId: { type: ["string", "null"] },
+        customerId: { type: ["string", "null"] },
+        assigneeId: { type: "string" },
+        type: {
+          type: "string",
+          enum: ["deadline", "meeting", "reminder", "delivery"]
+        },
+        status: {
+          type: "string",
+          enum: ["draft", "scheduled", "completed", "cancelled"]
+        }
       },
       required: ["id"]
     }
@@ -106494,120 +106687,661 @@ async function resolveTeamScope(requestedTeamId) {
   return { ok: true, teamIds, projectIds, customerIds };
 }
 
-// src/tools/customers.ts
-async function handleGetCustomers(input) {
-  const { q: q3, pageSize = 20 } = input;
-  const resolved = await resolveTeamId(input.teamId);
-  if (!resolved.ok) return resolved.response;
-  const customerIds = await getAccessibleCustomerIds(resolved.teamId);
-  if (customerIds.length === 0) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: "No customers found or no access to any customers."
-        }
-      ]
-    };
-  }
-  const filters = [inArray(schema_exports.customers.id, customerIds)];
-  if (q3) {
-    const pattern = `%${q3}%`;
-    filters.push(
-      or(
-        ilike(schema_exports.customers.name, pattern),
-        ilike(schema_exports.customers.email, pattern)
-      )
-    );
-  }
-  const rows = await db.select({
-    id: schema_exports.customers.id,
-    name: schema_exports.customers.name,
-    email: schema_exports.customers.email,
-    website: schema_exports.customers.website,
-    createdAt: schema_exports.customers.createdAt
-  }).from(schema_exports.customers).where(and(...filters)).orderBy(asc(schema_exports.customers.name)).limit(Math.min(pageSize, 100));
+// src/tools/ticket-access.ts
+function notFoundResponse(ticketId) {
   return {
     content: [
       {
         type: "text",
-        text: `Found ${rows.length} customers:
-
-${rows.map(
-          (c6) => `**${c6.name}**
-${c6.email ? `Email: ${c6.email}
-` : ""}${c6.website ? `Website: ${c6.website}
-` : ""}Created: ${new Date(c6.createdAt).toLocaleDateString()}
-`
-        ).join("\n") || "No customers found."}`
+        text: `Ticket not found or no access: ${ticketId}. Call get-tickets to find the correct ticket.`
       }
     ]
   };
 }
-async function handleCreateCustomer(input) {
-  const { name: name21, email: email5, website } = input;
-  const resolved = await resolveTeamId(input.teamId);
-  if (!resolved.ok) return resolved.response;
-  await db.insert(schema_exports.customers).values({
-    teamId: resolved.teamId,
-    name: name21,
-    email: email5 ?? "",
-    website: website ?? null
-  });
-  return {
-    content: [
-      {
-        type: "text",
-        text: `\u2705 **Customer Created Successfully!**
+async function loadAccessibleTicket(requestedTeamId, ticketId) {
+  const scope = await resolveTeamScope(requestedTeamId);
+  if (!scope.ok) return scope;
+  const [ticket] = await db.select({
+    id: schema_exports.tickets.id,
+    teamId: schema_exports.tickets.teamId,
+    projectId: schema_exports.tickets.projectId,
+    customerId: schema_exports.tickets.customerId,
+    ticketNumber: schema_exports.tickets.ticketNumber,
+    title: schema_exports.tickets.title,
+    status: schema_exports.tickets.status,
+    priority: schema_exports.tickets.priority,
+    type: schema_exports.tickets.type,
+    assigneeId: schema_exports.tickets.assigneeId
+  }).from(schema_exports.tickets).where(eq(schema_exports.tickets.id, ticketId)).limit(1);
+  if (!ticket) return { ok: false, response: notFoundResponse(ticketId) };
+  const hasAccess = scope.teamIds.includes(ticket.teamId) || !!ticket.projectId && scope.projectIds.includes(ticket.projectId) || !!ticket.customerId && scope.customerIds.includes(ticket.customerId);
+  if (!hasAccess) return { ok: false, response: notFoundResponse(ticketId) };
+  return { ok: true, ticket };
+}
 
-Name: ${name21}
-${email5 ? `Email: ${email5}
-` : ""}${website ? `Website: ${website}
-` : ""}`
-      }
-    ]
+// src/tools/calendar-items.ts
+function mapInputType(type) {
+  switch (type) {
+    case "reminder":
+      return "task";
+    case "delivery":
+      return "work";
+    default:
+      return type;
+  }
+}
+function mapOutputType(type, metadata) {
+  const meta5 = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : null;
+  const stored = meta5?.calendarType;
+  if (typeof stored === "string") return stored;
+  if (type === "task") return "reminder";
+  if (type === "work") return "delivery";
+  return type;
+}
+function mapOutputStatus(status, metadata, isDeleted) {
+  if (isDeleted) return "cancelled";
+  const meta5 = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : null;
+  if (meta5?.completed === true) return "completed";
+  return status === "draft" ? "draft" : "scheduled";
+}
+function parseDueDate(dueDate) {
+  const dateOnly = dueDate.split("T")[0];
+  return {
+    startTime: `${dateOnly}T00:00:00.000Z`,
+    endTime: `${dateOnly}T23:59:59.999Z`
   };
 }
-
-// ../document/src/humanizer/rules.ts
-var REPLACEMENTS = [
-  // --- Dutch clichés ---
-  { pattern: /\bbovendien\b/gi, replacement: "daarnaast", rule: "nl-cliche" },
-  { pattern: /\btevens\b/gi, replacement: "ook", rule: "nl-cliche" },
-  { pattern: /\bkortom\b/gi, replacement: "samengevat", rule: "nl-cliche" },
-  { pattern: /\bnaadloze\b/gi, replacement: "soepele", rule: "nl-cliche" },
-  { pattern: /\bnaadloos\b/gi, replacement: "soepel", rule: "nl-cliche" },
-  { pattern: /\brobuuste\b/gi, replacement: "solide", rule: "nl-cliche" },
-  { pattern: /\brobuust\b/gi, replacement: "solide", rule: "nl-cliche" },
-  { pattern: /\bcruciale\b/gi, replacement: "belangrijke", rule: "nl-cliche" },
-  { pattern: /\bcruciaal\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
-  {
-    pattern: /\bessentiële\b/gi,
-    replacement: "belangrijke",
-    rule: "nl-cliche"
-  },
-  { pattern: /\bessentieel\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
-  {
-    pattern: /\been breed scala aan\b/gi,
-    replacement: "veel",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\boptimaal benutten\b/gi,
-    replacement: "goed benutten",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\bin de wereld van vandaag\b/gi,
-    replacement: "vandaag de dag",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\bin het huidige digitale tijdperk\b/gi,
-    replacement: "tegenwoordig",
-    rule: "nl-cliche"
-  },
-  {
+function resolveEventTimes(input) {
+  if (input.dueDate) {
+    const { startTime, endTime } = parseDueDate(input.dueDate);
+    return { startTime, endTime, allDay: true };
+  }
+  if (input.startsAt) {
+    const startTime = input.startsAt.includes("T") ? input.startsAt : `${input.startsAt}T09:00:00.000Z`;
+    const endTime = input.endsAt ? input.endsAt.includes("T") ? input.endsAt : `${input.endsAt}T10:00:00.000Z` : null;
+    const allDay = input.type === "deadline" || !input.endsAt && !input.startsAt.includes(":");
+    return { startTime, endTime, allDay };
+  }
+  throw new Error(
+    "Provide dueDate (YYYY-MM-DD) or startsAt (ISO datetime) for the calendar item."
+  );
+}
+function formatCalendarItem(row) {
+  const dueDate = row.allDay || row.type === "deadline" ? row.startTime.split("T")[0] : void 0;
+  return {
+    id: row.id,
+    title: row.title,
+    description: row.description,
+    type: mapOutputType(row.type, row.metadata),
+    startsAt: row.startTime,
+    endsAt: row.endTime,
+    dueDate,
+    projectId: row.projectId,
+    customerId: row.customerId,
+    assigneeId: row.userId,
+    ticketIds: row.ticketIds,
+    status: mapOutputStatus(row.status, row.metadata, row.isDeleted)
+  };
+}
+async function loadTicketLinks(eventIds) {
+  const map3 = /* @__PURE__ */ new Map();
+  if (eventIds.length === 0) return map3;
+  const links = await db.select({
+    eventId: schema_exports.timesheetEventTickets.timesheetEventId,
+    ticketId: schema_exports.timesheetEventTickets.ticketId
+  }).from(schema_exports.timesheetEventTickets).where(
+    inArray(schema_exports.timesheetEventTickets.timesheetEventId, eventIds)
+  );
+  for (const link of links) {
+    const existing = map3.get(link.eventId) ?? [];
+    existing.push(link.ticketId);
+    map3.set(link.eventId, existing);
+  }
+  return map3;
+}
+async function findExistingTicketDeadline(teamId, ticketId) {
+  const links = await db.select({ eventId: schema_exports.timesheetEventTickets.timesheetEventId }).from(schema_exports.timesheetEventTickets).innerJoin(
+    schema_exports.timesheetEvents,
+    eq(
+      schema_exports.timesheetEvents.id,
+      schema_exports.timesheetEventTickets.timesheetEventId
+    )
+  ).where(
+    and(
+      eq(schema_exports.timesheetEventTickets.ticketId, ticketId),
+      eq(schema_exports.timesheetEvents.teamId, teamId),
+      eq(schema_exports.timesheetEvents.type, "deadline"),
+      eq(schema_exports.timesheetEvents.isDeleted, false)
+    )
+  ).limit(1);
+  return links[0]?.eventId ?? null;
+}
+async function validateProjectAccess(teamId, projectId, projectIds) {
+  if (!projectIds.includes(projectId)) {
+    throw new Error(
+      `Project not found or no access: ${projectId}. Call get-projects first.`
+    );
+  }
+}
+async function validateAssignee(teamId, assigneeId) {
+  const member2 = await isUserTeamMember(assigneeId, teamId);
+  if (!member2) {
+    throw new Error(
+      `Assignee ${assigneeId} is not a member of team ${teamId}.`
+    );
+  }
+}
+async function loadCalendarItemById(teamId, id) {
+  const [event] = await db.select({
+    id: schema_exports.timesheetEvents.id,
+    title: schema_exports.timesheetEvents.title,
+    description: schema_exports.timesheetEvents.description,
+    type: schema_exports.timesheetEvents.type,
+    status: schema_exports.timesheetEvents.status,
+    startTime: schema_exports.timesheetEvents.startTime,
+    endTime: schema_exports.timesheetEvents.endTime,
+    allDay: schema_exports.timesheetEvents.allDay,
+    projectId: schema_exports.timesheetEvents.projectId,
+    customerId: schema_exports.timesheetEvents.customerId,
+    userId: schema_exports.timesheetEvents.userId,
+    metadata: schema_exports.timesheetEvents.metadata,
+    isDeleted: schema_exports.timesheetEvents.isDeleted
+  }).from(schema_exports.timesheetEvents).where(
+    and(
+      eq(schema_exports.timesheetEvents.id, id),
+      eq(schema_exports.timesheetEvents.teamId, teamId),
+      eq(schema_exports.timesheetEvents.isDeleted, false)
+    )
+  ).limit(1);
+  if (!event) return null;
+  const ticketLinks = await loadTicketLinks([event.id]);
+  return {
+    ...event,
+    ticketIds: ticketLinks.get(event.id) ?? []
+  };
+}
+async function handleGetCalendarItems(input) {
+  getAuthContext();
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const teamIds = await getAccessibleTeamIds(teamId);
+  const pageSize = Math.min(input.pageSize ?? 50, 100);
+  const dateFrom = input.dateFrom ?? (/* @__PURE__ */ new Date()).toISOString().split("T")[0] + "T00:00:00.000Z";
+  const dateTo = input.dateTo ?? new Date(Date.now() + 90 * 24 * 60 * 60 * 1e3).toISOString();
+  const filters = [
+    inArray(schema_exports.timesheetEvents.teamId, teamIds),
+    gte(schema_exports.timesheetEvents.startTime, dateFrom),
+    lte(schema_exports.timesheetEvents.startTime, dateTo),
+    eq(schema_exports.timesheetEvents.isDeleted, false)
+  ];
+  if (input.projectId) {
+    filters.push(eq(schema_exports.timesheetEvents.projectId, input.projectId));
+  }
+  if (input.customerId) {
+    filters.push(eq(schema_exports.timesheetEvents.customerId, input.customerId));
+  }
+  if (input.assigneeId) {
+    filters.push(eq(schema_exports.timesheetEvents.userId, input.assigneeId));
+  }
+  if (input.status === "draft") {
+    filters.push(eq(schema_exports.timesheetEvents.status, "draft"));
+  } else if (input.status === "scheduled") {
+    filters.push(eq(schema_exports.timesheetEvents.status, "confirmed"));
+  }
+  let eventIdsForTicket;
+  if (input.ticketId) {
+    const links = await db.select({ eventId: schema_exports.timesheetEventTickets.timesheetEventId }).from(schema_exports.timesheetEventTickets).where(eq(schema_exports.timesheetEventTickets.ticketId, input.ticketId));
+    eventIdsForTicket = links.map((l4) => l4.eventId);
+    if (eventIdsForTicket.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ count: 0, items: [] }, null, 2)
+          }
+        ]
+      };
+    }
+    filters.push(inArray(schema_exports.timesheetEvents.id, eventIdsForTicket));
+  }
+  const rows = await db.select({
+    id: schema_exports.timesheetEvents.id,
+    title: schema_exports.timesheetEvents.title,
+    description: schema_exports.timesheetEvents.description,
+    type: schema_exports.timesheetEvents.type,
+    status: schema_exports.timesheetEvents.status,
+    startTime: schema_exports.timesheetEvents.startTime,
+    endTime: schema_exports.timesheetEvents.endTime,
+    allDay: schema_exports.timesheetEvents.allDay,
+    projectId: schema_exports.timesheetEvents.projectId,
+    customerId: schema_exports.timesheetEvents.customerId,
+    userId: schema_exports.timesheetEvents.userId,
+    metadata: schema_exports.timesheetEvents.metadata,
+    isDeleted: schema_exports.timesheetEvents.isDeleted
+  }).from(schema_exports.timesheetEvents).where(and(...filters)).orderBy(asc(schema_exports.timesheetEvents.startTime)).limit(pageSize);
+  const ticketLinks = await loadTicketLinks(rows.map((r6) => r6.id));
+  let items = rows.map(
+    (row) => formatCalendarItem({
+      ...row,
+      ticketIds: ticketLinks.get(row.id) ?? []
+    })
+  );
+  if (input.status === "completed") {
+    items = items.filter((item) => item.status === "completed");
+  } else if (input.status === "scheduled") {
+    items = items.filter((item) => item.status === "scheduled");
+  }
+  if (input.type) {
+    items = items.filter((item) => item.type === input.type);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ count: items.length, items }, null, 2)
+      }
+    ]
+  };
+}
+async function handleCreateCalendarItem(input) {
+  const ctx = getAuthContext();
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const projectIds = await getAccessibleProjectIds(ctx.userId, teamId);
+  const customerIds = await getAccessibleCustomerIds(teamId);
+  if (input.projectId) {
+    await validateProjectAccess(teamId, input.projectId, projectIds);
+  }
+  if (input.customerId && !customerIds.includes(input.customerId)) {
+    throw new Error(
+      `Customer not found or no access: ${input.customerId}. Call get-customers first.`
+    );
+  }
+  let ticketId = input.ticketId;
+  let projectId = input.projectId ?? null;
+  let customerId = input.customerId ?? null;
+  if (ticketId) {
+    const access = await loadAccessibleTicket(input.teamId, ticketId);
+    if (!access.ok) return access.response;
+    if (!projectId) projectId = access.ticket.projectId;
+    if (!customerId) customerId = access.ticket.customerId;
+  }
+  const itemType = input.type ?? "deadline";
+  const timesheetType = mapInputType(itemType);
+  if (ticketId && timesheetType === "deadline") {
+    const existingId = await findExistingTicketDeadline(teamId, ticketId);
+    if (existingId) {
+      return handleUpdateCalendarItem({
+        teamId: input.teamId,
+        id: existingId,
+        title: input.title,
+        description: input.description,
+        dueDate: input.dueDate,
+        startsAt: input.startsAt,
+        endsAt: input.endsAt,
+        projectId: projectId ?? void 0,
+        customerId: customerId ?? void 0,
+        assigneeId: input.assigneeId,
+        status: input.status,
+        type: itemType
+      });
+    }
+  }
+  const assigneeId = input.assigneeId ?? ctx.userId;
+  await validateAssignee(teamId, assigneeId);
+  const { startTime, endTime, allDay } = resolveEventTimes({
+    dueDate: input.dueDate,
+    startsAt: input.startsAt,
+    endsAt: input.endsAt,
+    type: itemType
+  });
+  const metadata = {
+    calendarType: itemType,
+    source: "mcp_calendar_item"
+  };
+  if (input.status === "completed") metadata.completed = true;
+  const [created] = await db.insert(schema_exports.timesheetEvents).values({
+    teamId,
+    userId: assigneeId,
+    title: input.title,
+    description: input.description ?? null,
+    type: timesheetType,
+    status: input.status === "draft" ? "draft" : "confirmed",
+    startTime,
+    endTime,
+    allDay,
+    projectId,
+    customerId,
+    metadata,
+    billingStatus: "unbillable"
+  }).returning({ id: schema_exports.timesheetEvents.id });
+  if (!created) throw new Error("Failed to create calendar item.");
+  if (ticketId) {
+    await db.insert(schema_exports.timesheetEventTickets).values({
+      timesheetEventId: created.id,
+      ticketId
+    });
+  }
+  const item = await loadCalendarItemById(teamId, created.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Calendar item created**
+
+` + JSON.stringify(formatCalendarItem(item), null, 2)
+      }
+    ]
+  };
+}
+async function handleUpdateCalendarItem(input) {
+  const ctx = getAuthContext();
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const existing = await loadCalendarItemById(teamId, input.id);
+  if (!existing) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Calendar item not found or no access: ${input.id}. Call get-calendar-items to find the correct id.`
+        }
+      ]
+    };
+  }
+  const projectIds = await getAccessibleProjectIds(ctx.userId, teamId);
+  const customerIds = await getAccessibleCustomerIds(teamId);
+  if (input.projectId) {
+    await validateProjectAccess(teamId, input.projectId, projectIds);
+  }
+  if (input.customerId && !customerIds.includes(input.customerId)) {
+    throw new Error(`Customer not found or no access: ${input.customerId}.`);
+  }
+  if (input.assigneeId) {
+    await validateAssignee(teamId, input.assigneeId);
+  }
+  const updateValues = {
+    updatedAt: sql`NOW()`
+  };
+  if (input.title !== void 0) updateValues.title = input.title;
+  if (input.description !== void 0) {
+    updateValues.description = input.description;
+  }
+  if (input.projectId !== void 0) updateValues.projectId = input.projectId;
+  if (input.customerId !== void 0) {
+    updateValues.customerId = input.customerId;
+  }
+  if (input.assigneeId !== void 0) updateValues.userId = input.assigneeId;
+  if (input.type !== void 0) {
+    updateValues.type = mapInputType(input.type);
+  }
+  if (input.dueDate !== void 0 || input.startsAt !== void 0 || input.endsAt !== void 0) {
+    const currentType = input.type ?? mapOutputType(existing.type, existing.metadata);
+    const { startTime, endTime, allDay } = resolveEventTimes({
+      dueDate: input.dueDate,
+      startsAt: input.startsAt ?? existing.startTime,
+      endsAt: input.endsAt ?? existing.endTime ?? void 0,
+      type: currentType
+    });
+    updateValues.startTime = startTime;
+    updateValues.endTime = endTime;
+    updateValues.allDay = allDay;
+  }
+  const existingMeta = existing.metadata && typeof existing.metadata === "object" && !Array.isArray(existing.metadata) ? existing.metadata : {};
+  const nextMeta = { ...existingMeta };
+  if (input.type !== void 0) nextMeta.calendarType = input.type;
+  if (input.status === "completed") {
+    nextMeta.completed = true;
+    updateValues.status = "confirmed";
+  } else if (input.status === "cancelled") {
+    await db.update(schema_exports.timesheetEvents).set({
+      isDeleted: true,
+      deletedAt: sql`NOW()`,
+      updatedAt: sql`NOW()`
+    }).where(
+      and(
+        eq(schema_exports.timesheetEvents.id, input.id),
+        eq(schema_exports.timesheetEvents.teamId, teamId)
+      )
+    );
+    const cancelled = await db.select({ id: schema_exports.timesheetEvents.id }).from(schema_exports.timesheetEvents).where(eq(schema_exports.timesheetEvents.id, input.id)).limit(1);
+    if (cancelled[0]) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2705 Calendar item ${input.id} cancelled (soft-deleted).`
+          }
+        ]
+      };
+    }
+  } else if (input.status === "draft") {
+    updateValues.status = "draft";
+    delete nextMeta.completed;
+  } else if (input.status === "scheduled") {
+    updateValues.status = "confirmed";
+    delete nextMeta.completed;
+  }
+  updateValues.metadata = nextMeta;
+  await db.update(schema_exports.timesheetEvents).set(updateValues).where(
+    and(
+      eq(schema_exports.timesheetEvents.id, input.id),
+      eq(schema_exports.timesheetEvents.teamId, teamId)
+    )
+  );
+  if (input.ticketId !== void 0) {
+    await db.delete(schema_exports.timesheetEventTickets).where(eq(schema_exports.timesheetEventTickets.timesheetEventId, input.id));
+    if (input.ticketId) {
+      const access = await loadAccessibleTicket(input.teamId, input.ticketId);
+      if (!access.ok) return access.response;
+      await db.insert(schema_exports.timesheetEventTickets).values({
+        timesheetEventId: input.id,
+        ticketId: input.ticketId
+      });
+    }
+  }
+  const item = await loadCalendarItemById(teamId, input.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Calendar item updated**
+
+` + JSON.stringify(formatCalendarItem(item), null, 2)
+      }
+    ]
+  };
+}
+async function syncTicketDeadline(teamId, ticket, dueDate) {
+  const ctx = getAuthContext();
+  if (dueDate === null) {
+    const existingId = await findExistingTicketDeadline(teamId, ticket.id);
+    if (existingId) {
+      await db.update(schema_exports.timesheetEvents).set({ isDeleted: true, deletedAt: sql`NOW()`, updatedAt: sql`NOW()` }).where(eq(schema_exports.timesheetEvents.id, existingId));
+    }
+    return "deadline removed";
+  }
+  if (dueDate) {
+    const title = `Deadline: ${ticket.title}`;
+    const { startTime, endTime, allDay } = parseDueDate(dueDate);
+    const assigneeId = ticket.assigneeId ?? ctx.userId;
+    const existingId = await findExistingTicketDeadline(teamId, ticket.id);
+    if (existingId) {
+      await db.update(schema_exports.timesheetEvents).set({
+        title,
+        startTime,
+        endTime,
+        allDay,
+        projectId: ticket.projectId,
+        customerId: ticket.customerId,
+        userId: assigneeId,
+        type: "deadline",
+        status: "confirmed",
+        metadata: {
+          calendarType: "deadline",
+          source: "mcp_ticket_due_date"
+        },
+        updatedAt: sql`NOW()`
+      }).where(eq(schema_exports.timesheetEvents.id, existingId));
+      return "deadline updated";
+    }
+    const [created] = await db.insert(schema_exports.timesheetEvents).values({
+      teamId,
+      userId: assigneeId,
+      title,
+      type: "deadline",
+      status: "confirmed",
+      startTime,
+      endTime,
+      allDay,
+      projectId: ticket.projectId,
+      customerId: ticket.customerId,
+      metadata: {
+        calendarType: "deadline",
+        source: "mcp_ticket_due_date"
+      },
+      billingStatus: "unbillable"
+    }).returning({ id: schema_exports.timesheetEvents.id });
+    if (created) {
+      await db.insert(schema_exports.timesheetEventTickets).values({
+        timesheetEventId: created.id,
+        ticketId: ticket.id
+      });
+    }
+    return "deadline created";
+  }
+  if (ticket.status === "resolved" || ticket.status === "closed") {
+    const existingId = await findExistingTicketDeadline(teamId, ticket.id);
+    if (existingId) {
+      const [existing] = await db.select({ metadata: schema_exports.timesheetEvents.metadata }).from(schema_exports.timesheetEvents).where(eq(schema_exports.timesheetEvents.id, existingId)).limit(1);
+      const meta5 = existing?.metadata && typeof existing.metadata === "object" && !Array.isArray(existing.metadata) ? existing.metadata : {};
+      await db.update(schema_exports.timesheetEvents).set({
+        metadata: { ...meta5, completed: true },
+        updatedAt: sql`NOW()`
+      }).where(eq(schema_exports.timesheetEvents.id, existingId));
+      return "deadline marked completed";
+    }
+  }
+  return null;
+}
+
+// src/tools/customers.ts
+async function handleGetCustomers(input) {
+  const { q: q3, pageSize = 20 } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const customerIds = await getAccessibleCustomerIds(resolved.teamId);
+  if (customerIds.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No customers found or no access to any customers."
+        }
+      ]
+    };
+  }
+  const filters = [inArray(schema_exports.customers.id, customerIds)];
+  if (q3) {
+    const pattern = `%${q3}%`;
+    filters.push(
+      or(
+        ilike(schema_exports.customers.name, pattern),
+        ilike(schema_exports.customers.email, pattern)
+      )
+    );
+  }
+  const rows = await db.select({
+    id: schema_exports.customers.id,
+    name: schema_exports.customers.name,
+    email: schema_exports.customers.email,
+    website: schema_exports.customers.website,
+    createdAt: schema_exports.customers.createdAt
+  }).from(schema_exports.customers).where(and(...filters)).orderBy(asc(schema_exports.customers.name)).limit(Math.min(pageSize, 100));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${rows.length} customers:
+
+${rows.map(
+          (c6) => `**${c6.name}**
+${c6.email ? `Email: ${c6.email}
+` : ""}${c6.website ? `Website: ${c6.website}
+` : ""}Created: ${new Date(c6.createdAt).toLocaleDateString()}
+`
+        ).join("\n") || "No customers found."}`
+      }
+    ]
+  };
+}
+async function handleCreateCustomer(input) {
+  const { name: name21, email: email5, website } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  await db.insert(schema_exports.customers).values({
+    teamId: resolved.teamId,
+    name: name21,
+    email: email5 ?? "",
+    website: website ?? null
+  });
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Customer Created Successfully!**
+
+Name: ${name21}
+${email5 ? `Email: ${email5}
+` : ""}${website ? `Website: ${website}
+` : ""}`
+      }
+    ]
+  };
+}
+
+// ../document/src/humanizer/rules.ts
+var REPLACEMENTS = [
+  // --- Dutch clichés ---
+  { pattern: /\bbovendien\b/gi, replacement: "daarnaast", rule: "nl-cliche" },
+  { pattern: /\btevens\b/gi, replacement: "ook", rule: "nl-cliche" },
+  { pattern: /\bkortom\b/gi, replacement: "samengevat", rule: "nl-cliche" },
+  { pattern: /\bnaadloze\b/gi, replacement: "soepele", rule: "nl-cliche" },
+  { pattern: /\bnaadloos\b/gi, replacement: "soepel", rule: "nl-cliche" },
+  { pattern: /\brobuuste\b/gi, replacement: "solide", rule: "nl-cliche" },
+  { pattern: /\brobuust\b/gi, replacement: "solide", rule: "nl-cliche" },
+  { pattern: /\bcruciale\b/gi, replacement: "belangrijke", rule: "nl-cliche" },
+  { pattern: /\bcruciaal\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
+  {
+    pattern: /\bessentiële\b/gi,
+    replacement: "belangrijke",
+    rule: "nl-cliche"
+  },
+  { pattern: /\bessentieel\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
+  {
+    pattern: /\been breed scala aan\b/gi,
+    replacement: "veel",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\boptimaal benutten\b/gi,
+    replacement: "goed benutten",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\bin de wereld van vandaag\b/gi,
+    replacement: "vandaag de dag",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\bin het huidige digitale tijdperk\b/gi,
+    replacement: "tegenwoordig",
+    rule: "nl-cliche"
+  },
+  {
     pattern: /\bstate-of-the-art\b/gi,
     replacement: "moderne",
     rule: "nl-cliche"
@@ -118800,38 +119534,6 @@ var storage = new Proxy({}, {
   }
 });
 
-// src/tools/ticket-access.ts
-function notFoundResponse(ticketId) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Ticket not found or no access: ${ticketId}. Call get-tickets to find the correct ticket.`
-      }
-    ]
-  };
-}
-async function loadAccessibleTicket(requestedTeamId, ticketId) {
-  const scope = await resolveTeamScope(requestedTeamId);
-  if (!scope.ok) return scope;
-  const [ticket] = await db.select({
-    id: schema_exports.tickets.id,
-    teamId: schema_exports.tickets.teamId,
-    projectId: schema_exports.tickets.projectId,
-    customerId: schema_exports.tickets.customerId,
-    ticketNumber: schema_exports.tickets.ticketNumber,
-    title: schema_exports.tickets.title,
-    status: schema_exports.tickets.status,
-    priority: schema_exports.tickets.priority,
-    type: schema_exports.tickets.type,
-    assigneeId: schema_exports.tickets.assigneeId
-  }).from(schema_exports.tickets).where(eq(schema_exports.tickets.id, ticketId)).limit(1);
-  if (!ticket) return { ok: false, response: notFoundResponse(ticketId) };
-  const hasAccess = scope.teamIds.includes(ticket.teamId) || !!ticket.projectId && scope.projectIds.includes(ticket.projectId) || !!ticket.customerId && scope.customerIds.includes(ticket.customerId);
-  if (!hasAccess) return { ok: false, response: notFoundResponse(ticketId) };
-  return { ok: true, ticket };
-}
-
 // src/tools/ticket-attachments.ts
 var ALLOWED_IMAGE_TYPES = [
   "image/jpeg",
@@ -119182,6 +119884,262 @@ ${rendered}`
   };
 }
 
+// src/tools/ticket-tags.ts
+function normalizeTagName(name21) {
+  return name21.toLowerCase().trim();
+}
+function formatTagList(tags2) {
+  if (tags2.length === 0) return "";
+  return tags2.map((t8) => t8.name).join(", ");
+}
+async function getTagsForTickets(ticketIds) {
+  const result = /* @__PURE__ */ new Map();
+  if (ticketIds.length === 0) return result;
+  const rows = await db.select({
+    ticketId: schema_exports.ticketTags.ticketId,
+    id: schema_exports.tags.id,
+    name: schema_exports.tags.name
+  }).from(schema_exports.ticketTags).innerJoin(schema_exports.tags, eq(schema_exports.tags.id, schema_exports.ticketTags.tagId)).where(inArray(schema_exports.ticketTags.ticketId, ticketIds)).orderBy(schema_exports.tags.name);
+  for (const row of rows) {
+    const existing = result.get(row.ticketId) ?? [];
+    existing.push({ id: row.id, name: row.name });
+    result.set(row.ticketId, existing);
+  }
+  return result;
+}
+async function resolveTagFilterIds(teamId, input) {
+  const ids = new Set(input.tagIds ?? []);
+  const names = [
+    ...input.tag ? [input.tag] : [],
+    ...input.tags ?? []
+  ].map(normalizeTagName).filter(Boolean);
+  if (names.length > 0) {
+    const nameConditions = names.map(
+      (name21) => sql`lower(${schema_exports.tags.name}) = ${name21}`
+    );
+    const rows = await db.select({ id: schema_exports.tags.id }).from(schema_exports.tags).where(and(eq(schema_exports.tags.teamId, teamId), or(...nameConditions)));
+    for (const row of rows) ids.add(row.id);
+  }
+  return [...ids];
+}
+async function resolveTags(teamId, input) {
+  const tags2 = [];
+  const errors = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  if (input.tagIds?.length) {
+    const rows = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(
+      and(
+        eq(schema_exports.tags.teamId, teamId),
+        inArray(schema_exports.tags.id, input.tagIds)
+      )
+    );
+    for (const row of rows) {
+      if (seenIds.has(row.id)) continue;
+      seenIds.add(row.id);
+      tags2.push(row);
+    }
+    for (const id of input.tagIds) {
+      if (!seenIds.has(id)) errors.push(`Unknown tag ID: ${id}`);
+    }
+  }
+  const rawNames = input.tagNames ?? [];
+  if (rawNames.length === 0) return { tags: tags2, errors };
+  const normalizedNames = [
+    ...new Set(rawNames.map(normalizeTagName).filter(Boolean))
+  ];
+  if (normalizedNames.length === 0) return { tags: tags2, errors };
+  const nameConditions = normalizedNames.map(
+    (name21) => sql`lower(${schema_exports.tags.name}) = ${name21}`
+  );
+  const existing = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(and(eq(schema_exports.tags.teamId, teamId), or(...nameConditions)));
+  const existingByNorm = /* @__PURE__ */ new Map();
+  for (const tag of existing) {
+    existingByNorm.set(normalizeTagName(tag.name), tag);
+  }
+  for (const rawName of rawNames) {
+    const norm = normalizeTagName(rawName);
+    if (!norm) continue;
+    const found = existingByNorm.get(norm);
+    if (found) {
+      if (!seenIds.has(found.id)) {
+        seenIds.add(found.id);
+        tags2.push(found);
+      }
+      continue;
+    }
+    if (!input.createMissing) {
+      errors.push(`Tag not found: ${rawName}`);
+      continue;
+    }
+    try {
+      const [created] = await db.insert(schema_exports.tags).values({
+        teamId,
+        name: norm,
+        projectId: input.projectId ?? null
+      }).returning({ id: schema_exports.tags.id, name: schema_exports.tags.name });
+      if (created) {
+        seenIds.add(created.id);
+        tags2.push(created);
+        existingByNorm.set(norm, created);
+      }
+    } catch {
+      const [retry2] = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(
+        and(
+          eq(schema_exports.tags.teamId, teamId),
+          sql`lower(${schema_exports.tags.name}) = ${norm}`,
+          input.projectId ? or(
+            eq(schema_exports.tags.projectId, input.projectId),
+            isNull(schema_exports.tags.projectId)
+          ) : isNull(schema_exports.tags.projectId)
+        )
+      ).limit(1);
+      if (retry2 && !seenIds.has(retry2.id)) {
+        seenIds.add(retry2.id);
+        tags2.push(retry2);
+        existingByNorm.set(norm, retry2);
+      } else {
+        errors.push(`Failed to create tag: ${rawName}`);
+      }
+    }
+  }
+  return { tags: tags2, errors };
+}
+async function syncTicketTags(ticketId, teamId, tagIds, mode = "replace") {
+  const current = await db.select({ tagId: schema_exports.ticketTags.tagId }).from(schema_exports.ticketTags).where(eq(schema_exports.ticketTags.ticketId, ticketId));
+  const currentIds = new Set(current.map((row) => row.tagId));
+  let targetIds;
+  if (mode === "remove") {
+    targetIds = new Set(
+      [...currentIds].filter((id) => !tagIds.includes(id))
+    );
+  } else if (mode === "merge") {
+    targetIds = /* @__PURE__ */ new Set([...currentIds, ...tagIds]);
+  } else {
+    targetIds = new Set(tagIds);
+  }
+  const toInsert = [...targetIds].filter((id) => !currentIds.has(id));
+  const toDelete = [...currentIds].filter((id) => !targetIds.has(id));
+  if (toDelete.length > 0) {
+    await db.delete(schema_exports.ticketTags).where(
+      and(
+        eq(schema_exports.ticketTags.ticketId, ticketId),
+        inArray(schema_exports.ticketTags.tagId, toDelete)
+      )
+    );
+  }
+  if (toInsert.length > 0) {
+    await db.insert(schema_exports.ticketTags).values(
+      toInsert.map((tagId) => ({
+        ticketId,
+        tagId,
+        teamId
+      }))
+    );
+  }
+  const tagIdsToDescribe = [.../* @__PURE__ */ new Set([...toInsert, ...toDelete])];
+  const tagNamesById = /* @__PURE__ */ new Map();
+  if (tagIdsToDescribe.length > 0) {
+    const rows = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(inArray(schema_exports.tags.id, tagIdsToDescribe));
+    for (const row of rows) tagNamesById.set(row.id, row.name);
+  }
+  return {
+    added: toInsert.map((id) => tagNamesById.get(id) ?? id),
+    removed: toDelete.map((id) => tagNamesById.get(id) ?? id)
+  };
+}
+
+// src/tools/tags.ts
+async function handleGetTags(input) {
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const filters = [eq(schema_exports.tags.teamId, resolved.teamId)];
+  if (input.projectId !== void 0) {
+    filters.push(
+      or(
+        eq(schema_exports.tags.projectId, input.projectId),
+        isNull(schema_exports.tags.projectId)
+      )
+    );
+  }
+  const rows = await db.select({
+    id: schema_exports.tags.id,
+    name: schema_exports.tags.name,
+    projectId: schema_exports.tags.projectId,
+    createdAt: schema_exports.tags.createdAt
+  }).from(schema_exports.tags).where(and(...filters)).orderBy(asc(schema_exports.tags.name)).limit(Math.min(input.pageSize ?? 100, 200));
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${rows.length} tags (team-specific${input.projectId ? ", including general tags for this project" : ""}):
+
+` + (rows.map(
+          (tag) => `**${tag.name}** (id: ${tag.id})${tag.projectId ? " [project-specific]" : " [general]"}`
+        ).join("\n") || "No tags found.")
+      }
+    ]
+  };
+}
+async function handleCreateTag(input) {
+  const name21 = input.name.trim();
+  if (!name21) {
+    return {
+      content: [{ type: "text", text: "Tag name is required." }]
+    };
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const normalized = normalizeTagName(name21);
+  const scopeFilter = input.projectId ? eq(schema_exports.tags.projectId, input.projectId) : isNull(schema_exports.tags.projectId);
+  const [existing] = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(
+    and(
+      eq(schema_exports.tags.teamId, resolved.teamId),
+      scopeFilter,
+      sql`lower(${schema_exports.tags.name}) = ${normalized}`
+    )
+  ).limit(1);
+  if (existing) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u2139\uFE0F Tag already exists (case-insensitive match):
+
+Name: **${existing.name}**
+ID: ${existing.id}`
+        }
+      ]
+    };
+  }
+  const [created] = await db.insert(schema_exports.tags).values({
+    teamId: resolved.teamId,
+    name: name21,
+    projectId: input.projectId ?? null
+  }).returning({
+    id: schema_exports.tags.id,
+    name: schema_exports.tags.name,
+    projectId: schema_exports.tags.projectId
+  });
+  if (!created) {
+    return {
+      content: [{ type: "text", text: "Failed to create tag." }]
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Tag Created**
+
+Name: **${created.name}**
+ID: ${created.id}
+${created.projectId ? `Project ID: ${created.projectId}
+` : "Scope: general (team-wide)\n"}`
+      }
+    ]
+  };
+}
+
 // src/tools/ticket-update.ts
 async function handleUpdateTicket(input) {
   const ctx = getAuthContext();
@@ -119227,6 +120185,38 @@ async function handleUpdateTicket(input) {
   if (input.estimatedHours !== void 0) {
     updateValues.estimatedHours = input.estimatedHours;
   }
+  if (input.dueDate !== void 0) {
+    updateValues.dueDate = input.dueDate;
+    updateValues.dueDateAllDay = input.dueDate ? true : false;
+  }
+  let deadlineChange = null;
+  if (input.dueDate !== void 0) {
+    deadlineChange = await syncTicketDeadline(
+      ticket.teamId,
+      {
+        id: ticket.id,
+        title: input.title ?? ticket.title,
+        status: input.status ?? ticket.status,
+        projectId: input.projectId ?? ticket.projectId,
+        customerId: input.customerId ?? ticket.customerId,
+        assigneeId: input.assigneeId !== void 0 ? input.assigneeId : ticket.assigneeId
+      },
+      input.dueDate
+    );
+  } else if (input.status !== void 0 && (input.status === "resolved" || input.status === "closed") && input.status !== ticket.status) {
+    deadlineChange = await syncTicketDeadline(
+      ticket.teamId,
+      {
+        id: ticket.id,
+        title: input.title ?? ticket.title,
+        status: input.status,
+        projectId: input.projectId ?? ticket.projectId,
+        customerId: input.customerId ?? ticket.customerId,
+        assigneeId: input.assigneeId !== void 0 ? input.assigneeId : ticket.assigneeId
+      },
+      void 0
+    );
+  }
   await db.update(schema_exports.tickets).set(updateValues).where(eq(schema_exports.tickets.id, ticket.id));
   const changes = [];
   const activities2 = [];
@@ -119271,6 +120261,61 @@ async function handleUpdateTicket(input) {
   if (input.projectId !== void 0) changes.push("project updated");
   if (input.customerId !== void 0) changes.push("customer updated");
   if (input.estimatedHours !== void 0) changes.push("estimated hours updated");
+  if (deadlineChange) changes.push(deadlineChange);
+  if (input.tags !== void 0 || input.tagIds !== void 0) {
+    const tagMode = input.tagMode ?? "replace";
+    const createMissing = tagMode === "replace" || tagMode === "merge";
+    const resolvedTags = await resolveTags(ticket.teamId, {
+      tagNames: input.tags,
+      tagIds: input.tagIds,
+      projectId: input.projectId ?? ticket.projectId,
+      createMissing
+    });
+    if (resolvedTags.errors.length > 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Cannot update tags on ${ticket.ticketNumber}:
+` + resolvedTags.errors.map((e6) => `   \u2022 ${e6}`).join("\n")
+          }
+        ]
+      };
+    }
+    const { added, removed } = await syncTicketTags(
+      ticket.id,
+      ticket.teamId,
+      resolvedTags.tags.map((t8) => t8.id),
+      tagMode
+    );
+    if (added.length > 0) {
+      changes.push(`tags added: ${added.join(", ")}`);
+      for (const tagName of added) {
+        await db.insert(schema_exports.ticketActivity).values({
+          ticketId: ticket.id,
+          teamId: ticket.teamId,
+          userId: ctx.userId,
+          activityType: "tag_added",
+          newValue: tagName
+        });
+      }
+    }
+    if (removed.length > 0) {
+      changes.push(`tags removed: ${removed.join(", ")}`);
+      for (const tagName of removed) {
+        await db.insert(schema_exports.ticketActivity).values({
+          ticketId: ticket.id,
+          teamId: ticket.teamId,
+          userId: ctx.userId,
+          activityType: "tag_removed",
+          newValue: tagName
+        });
+      }
+    }
+    if (tagMode === "replace" && added.length === 0 && removed.length === 0) {
+      changes.push("tags cleared");
+    }
+  }
   for (const activity of activities2) {
     await db.insert(schema_exports.ticketActivity).values({
       ticketId: ticket.id,
@@ -119330,7 +120375,17 @@ async function downloadImageAsBase64(storageKey) {
 }
 async function handleGetTickets(input) {
   const ctx = getAuthContext();
-  const { status, priority, projectId, customerId, q: q3, pageSize = 20 } = input;
+  const {
+    status,
+    priority,
+    projectId,
+    customerId,
+    q: q3,
+    tag,
+    tags: tags2,
+    tagIds,
+    pageSize = 20
+  } = input;
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const teamId = resolved.teamId;
@@ -119357,6 +120412,29 @@ async function handleGetTickets(input) {
       )
     );
   }
+  const filterTagIds = await resolveTagFilterIds(teamId, { tag, tags: tags2, tagIds });
+  if (tag || tags2?.length || tagIds?.length) {
+    if (filterTagIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No tickets found (no matching tags for the given filter)."
+          }
+        ]
+      };
+    }
+    filters.push(
+      sql`EXISTS (
+        SELECT 1 FROM ${schema_exports.ticketTags}
+        WHERE ${schema_exports.ticketTags.ticketId} = ${schema_exports.tickets.id}
+        AND ${schema_exports.ticketTags.tagId} IN (${sql.join(
+        filterTagIds.map((id) => sql`${id}`),
+        sql`, `
+      )})
+      )`
+    );
+  }
   const rows = await db.select({
     id: schema_exports.tickets.id,
     ticketNumber: schema_exports.tickets.ticketNumber,
@@ -119374,20 +120452,23 @@ async function handleGetTickets(input) {
     schema_exports.customers,
     eq(schema_exports.customers.id, schema_exports.tickets.customerId)
   ).where(and(...filters)).orderBy(desc(schema_exports.tickets.createdAt)).limit(Math.min(pageSize, 100));
+  const tagsByTicket = await getTagsForTickets(rows.map((t8) => t8.id));
   return {
     content: [
       {
         type: "text",
         text: `Found ${rows.length} tickets:
 
-${rows.map(
-          (t8) => `**${t8.ticketNumber}**: ${t8.title}
+${rows.map((t8) => {
+          const ticketTags2 = tagsByTicket.get(t8.id) ?? [];
+          return `**${t8.ticketNumber}**: ${t8.title}
 Status: ${t8.status} | Priority: ${t8.priority}
-${t8.projectName ? `Project: ${t8.projectName}
+${ticketTags2.length > 0 ? `Tags: ${formatTagList(ticketTags2)}
+` : ""}${t8.projectName ? `Project: ${t8.projectName}
 ` : ""}${t8.customerName ? `Customer: ${t8.customerName}
 ` : ""}Created: ${new Date(t8.createdAt).toLocaleDateString()}
-`
-        ).join("\n") || "No tickets found."}`
+`;
+        }).join("\n") || "No tickets found."}`
       }
     ]
   };
@@ -119500,6 +120581,11 @@ ${text3.split("\n").map((l4) => `     ${l4}`).join("\n")}`;
   const assigneeLine = ticketRow.assignee ? `Assignee: ${ticketRow.assignee.fullName || "Unknown"} [id: ${ticketRow.assignee.id}]
 ` : ticketRow.requester ? `Assignee: (unassigned) \u2014 use requester id ${ticketRow.requester.id} for review handoff
 ` : `Assignee: (unassigned)
+`;
+  const ticketTagRows = await getTagsForTickets([id]);
+  const ticketTags2 = ticketTagRows.get(id) ?? [];
+  const tagsLine = ticketTags2.length > 0 ? `Tags: ${formatTagList(ticketTags2)}
+` : `Tags: (none)
 `;
   const content = [
     {
@@ -119512,10 +120598,11 @@ Team id: ${ticketRow.teamId}
 Status: ${ticketRow.status}
 Priority: ${ticketRow.priority}
 Type: ${ticketRow.type}
-${ticketRow.description ? `Description: ${tiptapToPlainText(ticketRow.description)}
+${ticketRow.dueDate ? `Deadline: ${new Date(ticketRow.dueDate).toLocaleDateString()}
+` : ""}${ticketRow.description ? `Description: ${tiptapToPlainText(ticketRow.description)}
 ` : ""}${ticketRow.project?.name ? `Project: ${ticketRow.project.name}
 ` : ""}${ticketRow.customer?.name ? `Customer: ${ticketRow.customer.name}
-` : ""}` + assigneeLine + requesterLine + `Created: ${new Date(ticketRow.createdAt).toLocaleDateString()}
+` : ""}` + tagsLine + assigneeLine + requesterLine + `Created: ${new Date(ticketRow.createdAt).toLocaleDateString()}
 ` + attachmentList + commentList
     }
   ];
@@ -119592,7 +120679,10 @@ async function handleCreateTicket(input) {
     priority = "medium",
     type = "task",
     projectId,
-    customerId
+    customerId,
+    dueDate,
+    tags: tags2,
+    tagIds
   } = input;
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
@@ -119649,7 +120739,7 @@ async function handleCreateTicket(input) {
     const count = Number(countRow?.n ?? 0);
     ticketNumber = `${year2}-${String(count + 1).padStart(3, "0")}`;
   }
-  await db.insert(schema_exports.tickets).values({
+  const [created] = await db.insert(schema_exports.tickets).values({
     teamId: resolvedTeamId,
     ticketNumber,
     title,
@@ -119659,20 +120749,54 @@ async function handleCreateTicket(input) {
     type,
     projectId: projectId ?? null,
     customerId: resolvedCustomerId ?? null,
-    requesterId: ctx.userId
+    requesterId: ctx.userId,
+    dueDate: dueDate ?? null,
+    dueDateAllDay: dueDate ? true : false
+  }).returning({
+    id: schema_exports.tickets.id,
+    ticketNumber: schema_exports.tickets.ticketNumber
   });
+  if (!created) {
+    throw new Error("Failed to create ticket");
+  }
+  let appliedTags = [];
+  const tagErrors = [];
+  if ((tags2?.length ?? 0) > 0 || (tagIds?.length ?? 0) > 0) {
+    const resolvedTags = await resolveTags(resolvedTeamId, {
+      tagNames: tags2,
+      tagIds,
+      projectId: projectId ?? null,
+      createMissing: true
+    });
+    tagErrors.push(...resolvedTags.errors);
+    if (resolvedTags.tags.length > 0) {
+      await syncTicketTags(
+        created.id,
+        resolvedTeamId,
+        resolvedTags.tags.map((t8) => t8.id),
+        "replace"
+      );
+      appliedTags = resolvedTags.tags;
+    }
+  }
   return {
     content: [
       {
         type: "text",
         text: `\u2705 **Ticket Created Successfully!**
 
-Ticket Number: **${ticketNumber}**
+Ticket Number: **${created.ticketNumber}**
+ID: ${created.id}
 Title: ${title}
 Status: ${status}
 Priority: ${priority}
 Type: ${type}
-`
+${dueDate ? `Deadline: ${new Date(dueDate).toLocaleDateString()}
+` : ""}${appliedTags.length > 0 ? `Tags: ${formatTagList(appliedTags)}
+` : ""}${tagErrors.length > 0 ? `
+\u26A0\uFE0F Tag warnings:
+${tagErrors.map((e6) => `   \u2022 ${e6}`).join("\n")}
+` : ""}`
       }
     ]
   };
@@ -119723,6 +120847,22 @@ function createMcpServer() {
           return await handleCreateTicket(asToolArgs(toolArgs));
         case "update-ticket":
           return await handleUpdateTicket(asToolArgs(toolArgs));
+        case "get-tags":
+          return await handleGetTags(asToolArgs(toolArgs));
+        case "create-tag":
+          return await handleCreateTag(asToolArgs(toolArgs));
+        case "get-calendar-items":
+          return await handleGetCalendarItems(
+            asToolArgs(toolArgs)
+          );
+        case "create-calendar-item":
+          return await handleCreateCalendarItem(
+            asToolArgs(toolArgs)
+          );
+        case "update-calendar-item":
+          return await handleUpdateCalendarItem(
+            asToolArgs(toolArgs)
+          );
         case "add-ticket-comment":
           return await handleAddTicketComment(
             asToolArgs(toolArgs)