@mgsoftwarebv/mcp-server-bridge 3.4.1 → 3.5.1

package/dist/index.js

@@ -6170,20 +6170,20 @@ var require_resolve = __commonJS({
       return false;
     }
     function countKeys(schema) {
-      let count = 0;
+      let count2 = 0;
       for (const key in schema) {
         if (key === "$ref")
           return Infinity;
-        count++;
+        count2++;
         if (SIMPLE_INLINED.has(key))
           continue;
         if (typeof schema[key] == "object") {
-          (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
+          (0, util_1.eachItem)(schema[key], (sch) => count2 += countKeys(sch));
         }
-        if (count === Infinity)
+        if (count2 === Infinity)
           return Infinity;
       }
-      return count;
+      return count2;
     }
     function getFullPath(resolver, id = "", normalize2) {
       if (normalize2 !== false)
@@ -9228,8 +9228,8 @@ var require_contains = __commonJS({
         cxt.result(valid, () => cxt.reset());
         function validateItemsWithCount() {
           const schValid = gen.name("_valid");
-          const count = gen.let("count", 0);
-          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
+          const count2 = gen.let("count", 0);
+          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count2)));
         }
         function validateItems(_valid, block) {
           gen.forRange("i", 0, len, (i6) => {
@@ -9242,16 +9242,16 @@ var require_contains = __commonJS({
             block();
           });
         }
-        function checkLimits(count) {
-          gen.code((0, codegen_1._)`${count}++`);
+        function checkLimits(count2) {
+          gen.code((0, codegen_1._)`${count2}++`);
           if (max === void 0) {
-            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
+            gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true).break());
           } else {
-            gen.if((0, codegen_1._)`${count} > ${max}`, () => gen.assign(valid, false).break());
+            gen.if((0, codegen_1._)`${count2} > ${max}`, () => gen.assign(valid, false).break());
             if (min === 1)
               gen.assign(valid, true);
             else
-              gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
+              gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true));
           }
         }
       }
@@ -15018,8 +15018,8 @@ var init_az = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -16933,8 +16933,8 @@ var init_hu = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -19049,8 +19049,8 @@ var init_pt = __esm({
 });
 
 // ../../node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -59475,9 +59475,9 @@ var init_DefaultRetryToken = __esm({
       count;
       cost;
       longPoll;
-      constructor(delay2, count, cost, longPoll) {
+      constructor(delay2, count2, cost, longPoll) {
         this.delay = delay2;
-        this.count = count;
+        this.count = count2;
         this.cost = cost;
         this.longPoll = longPoll;
       }
@@ -62418,9 +62418,9 @@ function validateAmpersand(xmlData, i6) {
     i6++;
     return validateNumberAmpersand(xmlData, i6);
   }
-  let count = 0;
-  for (; i6 < xmlData.length; i6++, count++) {
-    if (xmlData[i6].match(/\w/) && count < 20)
+  let count2 = 0;
+  for (; i6 < xmlData.length; i6++, count2++) {
+    if (xmlData[i6].match(/\w/) && count2 < 20)
       continue;
     if (xmlData[i6] === ";")
       break;
@@ -65059,8 +65059,8 @@ var init_Matcher = __esm({
         const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;
         const counter = siblings.get(siblingKey) || 0;
         let position = 0;
-        for (const count of siblings.values()) {
-          position += count;
+        for (const count2 of siblings.values()) {
+          position += count2;
         }
         siblings.set(siblingKey, counter + 1);
         const node = {
@@ -86413,6 +86413,11 @@ function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelect
   return result;
 }
 
+// ../../node_modules/drizzle-orm/sql/functions/aggregate.js
+function count(expression) {
+  return sql`count(${sql.raw("*")})`.mapWith(Number);
+}
+
 // ../../node_modules/postgres/src/query.js
 var originCache = /* @__PURE__ */ new Map();
 var originStackCache = /* @__PURE__ */ new Map();
@@ -105727,6 +105732,70 @@ var TOOLS = [
       required: ["name"]
     }
   },
+  {
+    name: "update-tag",
+    description: "Rename a team tag and/or change its scope. Provide `name` to rename (a case-insensitive name collision in the same scope is rejected \u2014 use merge-tags instead), and/or `projectId` to re-scope (a project UUID, or null for a general team tag). Existing ticket/customer/project/transaction tag relations are preserved. Find tag ids via get-tags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        tagId: { type: "string", description: "Tag ID (UUID) to update" },
+        name: { type: "string", description: "New tag name" },
+        projectId: {
+          type: ["string", "null"],
+          description: "Project UUID to make it project-specific, or null for a general team tag"
+        }
+      },
+      required: ["tagId"]
+    }
+  },
+  {
+    name: "delete-tag",
+    description: "Delete a team tag SAFELY. With mode 'delete_if_unused' (default) the tag is hard-deleted only when it is not used by any ticket/customer/project/transaction; if it is still used, the call is refused and usage counts are returned (it never strips the tag off entities). Mode 'archive' is not supported (the tags table has no archived column) \u2014 use merge-tags to fold a used tag into another, then delete the empty tag.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        tagId: { type: "string", description: "Tag ID (UUID) to delete" },
+        mode: {
+          type: "string",
+          enum: ["delete_if_unused", "archive"],
+          default: "delete_if_unused",
+          description: "delete_if_unused = hard-delete only when unused (default); archive = unsupported, returns guidance"
+        }
+      },
+      required: ["tagId"]
+    }
+  },
+  {
+    name: "merge-tags",
+    description: "Merge one or more duplicate/misspelled source tags into a single target tag. Specify the target by `targetTagId` (existing) or `targetName` (reused if it exists, otherwise created as a general team tag). All ticket/customer/project/transaction relations are moved onto the target without creating duplicates (entities that already have the target keep a single tag). By default the empty source tags are deleted afterwards (set deleteSources=false to keep them). Returns moved/skipped counts per entity type. Find tag ids via get-tags.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        sourceTagIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Tag IDs to merge away (at least one)"
+        },
+        targetTagId: {
+          type: "string",
+          description: "Existing target tag ID (takes precedence over targetName)"
+        },
+        targetName: {
+          type: "string",
+          description: "Target tag name; an existing match is reused, otherwise a general tag is created"
+        },
+        deleteSources: {
+          type: "boolean",
+          default: true,
+          description: "Delete the now-empty source tags after merging"
+        }
+      },
+      required: ["sourceTagIds"]
+    }
+  },
   {
     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.",
@@ -105905,7 +105974,7 @@ var TOOLS = [
   },
   {
     name: "get-customers",
-    description: "Get customers with optional search",
+    description: "Get customers with optional search. Each result includes its ID (UUID), name, email, website, phone, status, archived flag, and created date. Archived customers are hidden by default; pass status 'archived' or 'all' to include them.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105914,6 +105983,12 @@ var TOOLS = [
           type: "string",
           description: "Search query for customer name or email"
         },
+        status: {
+          type: "string",
+          enum: ["active", "archived", "all"],
+          default: "active",
+          description: "Archive filter: 'active' (default, hides archived), 'archived', or 'all'."
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -105921,7 +105996,7 @@ var TOOLS = [
   },
   {
     name: "create-customer",
-    description: "Create a new customer",
+    description: "Create a new customer. Returns the created customer including its ID (UUID).",
     inputSchema: {
       type: "object",
       properties: {
@@ -105933,15 +106008,109 @@ var TOOLS = [
       required: ["name"]
     }
   },
+  {
+    name: "update-customer",
+    description: "Update an existing customer's editable fields. Use this to fix a customer that was created with a wrong name/email/website. Only provided fields change. Set isArchived to false to reactivate an archived customer, or true to archive it (archive-customer is the friendlier way). Find the customer id via get-customers.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Customer ID (UUID) to update" },
+        name: { type: "string" },
+        email: {
+          type: "string",
+          description: "Email (required column \u2014 cannot be set empty)."
+        },
+        website: { type: ["string", "null"] },
+        phone: { type: ["string", "null"] },
+        companyName: { type: ["string", "null"] },
+        billingEmail: { type: ["string", "null"] },
+        vatNumber: { type: ["string", "null"] },
+        contact: { type: ["string", "null"] },
+        note: { type: ["string", "null"] },
+        addressLine1: { type: ["string", "null"] },
+        addressLine2: { type: ["string", "null"] },
+        city: { type: ["string", "null"] },
+        state: { type: ["string", "null"] },
+        zip: { type: ["string", "null"] },
+        country: { type: ["string", "null"] },
+        countryCode: { type: ["string", "null"] },
+        status: {
+          type: "string",
+          enum: ["active", "inactive", "prospect", "churned"],
+          description: "Customer relationship status."
+        },
+        isArchived: {
+          type: "boolean",
+          description: "Set false to reactivate an archived customer, true to archive."
+        }
+      },
+      required: ["customerId"]
+    }
+  },
+  {
+    name: "archive-customer",
+    description: "Safely archive (soft-retire) a customer \u2014 the recommended way to clean up a mistakenly-created customer. Reversible and non-destructive: it keeps all projects, tickets, invoices, documents and other data, sets is_archived=true (status=inactive) and only hides the customer from get-customers by default. Identify the customer by `customerId` (preferred), or by an exact `customerName` and/or `email` \u2014 if more than one customer matches, the call is refused and the matches are listed. Use update-customer (isArchived: false) to reactivate.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Customer ID (UUID) to archive" },
+        customerName: {
+          type: "string",
+          description: "Exact customer name (case-insensitive). Refused if it matches multiple customers."
+        },
+        email: {
+          type: "string",
+          description: "Exact customer email (case-insensitive). Refused if it matches multiple customers."
+        },
+        reason: {
+          type: "string",
+          description: "Optional note explaining why the customer is archived"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "delete-customer",
+    description: "Permanently hard-delete a customer, but ONLY when it is empty (no projects, tickets, invoices, quotations, documents, agenda/time entries, timesheet templates, trips, or trip templates). If any such dependencies exist the delete is rejected with a dependency summary \u2014 use archive-customer instead (deleting would cascade-delete the customer's projects). Identify the customer by `customerId` (preferred) or an exact `customerName`/`email` (refused on multiple matches). Requires team OWNER privileges and confirmEmptyOnly: true as an explicit safety interlock.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Customer ID (UUID) to delete" },
+        customerName: {
+          type: "string",
+          description: "Exact customer name (case-insensitive). Refused on multiple matches."
+        },
+        email: {
+          type: "string",
+          description: "Exact customer email (case-insensitive). Refused on multiple matches."
+        },
+        confirmEmptyOnly: {
+          type: "boolean",
+          description: "Must be true to authorise the hard delete of an empty customer."
+        }
+      },
+      required: []
+    }
+  },
   {
     name: "get-projects",
-    description: "Get projects with optional filtering",
+    description: "Get projects with optional filtering. Each project includes its ID and, when archived, its archive timestamp/reason. Archived projects are hidden by default; pass status 'archived' or 'all' to include them.",
     inputSchema: {
       type: "object",
       properties: {
         teamId: teamIdProp,
         customerId: { type: "string", description: "Filter by customer ID" },
         q: { type: "string", description: "Search query for project name" },
+        status: {
+          type: "string",
+          enum: ["active", "archived", "all"],
+          default: "active",
+          description: "Archive filter: 'active' (default, hides archived), 'archived', or 'all'."
+        },
         pageSize: { type: "number", default: 20, maximum: 100 }
       },
       required: []
@@ -105968,7 +106137,7 @@ var TOOLS = [
   },
   {
     name: "update-project",
-    description: "Update an existing project's fields (name, description, customer, rate, currency, billable, estimate, internal). Only provided fields change. Renaming a project renumbers its tickets. There is no project 'status' field. Find the project id via get-projects.",
+    description: "Update an existing project's fields (name, description, customer, rate, currency, billable, estimate, internal). Only provided fields change. Renaming a project renumbers its tickets. To retire a mistakenly-created project use archive-project (reversible) or delete-project (empty projects only). Find the project id via get-projects.",
     inputSchema: {
       type: "object",
       properties: {
@@ -105995,6 +106164,38 @@ var TOOLS = [
       required: ["id"]
     }
   },
+  {
+    name: "archive-project",
+    description: "Safely archive (soft-retire) a project \u2014 the recommended way to clean up a mistakenly-created project. Reversible and non-destructive: it keeps all tickets, hours, trips, documents and other data, and only hides the project from get-projects by default. Use this instead of delete-project whenever a project has any history. Find the project id via get-projects. Note: the archive flag is stored in projects.settings.archivedAt; the dashboard UI does not yet read it, so the project still appears there.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        projectId: { type: "string", description: "Project ID to archive" },
+        reason: {
+          type: "string",
+          description: "Optional note explaining why the project is archived"
+        }
+      },
+      required: ["projectId"]
+    }
+  },
+  {
+    name: "delete-project",
+    description: "Permanently hard-delete a project, but ONLY when it is empty (no tickets, agenda/time entries, timesheet templates, trips, or trip templates). If any such dependencies exist the delete is rejected with a dependency summary \u2014 archive-project instead. Requires team OWNER privileges and confirmEmptyOnly: true as an explicit safety interlock. Prefer archive-project unless you are certain the project should be erased.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        projectId: { type: "string", description: "Project ID to delete" },
+        confirmEmptyOnly: {
+          type: "boolean",
+          description: "Must be true to authorise the hard delete of an empty project."
+        }
+      },
+      required: ["projectId"]
+    }
+  },
   {
     name: "get-project-members",
     description: "List the members explicitly assigned to a project (member_project_access) plus the full team roster with each member's effective access. Use the returned userIds with set/add/remove-project-member. Access model: owners and members with no restrictions see ALL projects; once a member is explicitly assigned to ANY project they can ONLY see their explicitly-assigned projects.",
@@ -106377,6 +106578,148 @@ var TOOLS = [
       required: ["productId"]
     }
   },
+  {
+    name: "get-quotes",
+    description: "List quotes/offertes (the `quotations` module) with optional filtering by customer, status, or a search on quote number / customer name. Each entry includes its ID (UUID), quote number, customer, status, totals (amount/subtotal/VAT), validUntil and createdAt. Note: quotations are not linked to projects, so `projectId` is accepted but ignored.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Filter by customer ID" },
+        projectId: {
+          type: "string",
+          description: "Accepted for API symmetry but ignored (quotes are not linked to projects)."
+        },
+        status: {
+          type: "string",
+          enum: ["draft", "sent", "accepted", "rejected", "expired"],
+          description: "Filter by quote status (e.g. 'draft' for concepts)"
+        },
+        q: {
+          type: "string",
+          description: "Search query for quote number or customer name"
+        },
+        pageSize: { type: "number", default: 20, maximum: 100 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create-quote",
+    description: "Create a DRAFT quote/offerte for a customer. Draft-only by design: this tool can only create status `draft` and rejects any other status \u2014 sending/accepting a quote stays a manual dashboard action. Applies the team's default quotation template (currency, VAT rate, labels) and computes totals. `lineItems` may be free-form ({name, quantity, unit, price}) or product-backed ({productId, quantity, optional name/price overrides}); product-backed items store an immutable product snapshot on the line item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Customer ID (required)" },
+        projectId: {
+          type: "string",
+          description: "Accepted for API symmetry but not persisted on quotes."
+        },
+        title: {
+          type: "string",
+          description: "Overrides the per-quote template title (e.g. 'Offerte')."
+        },
+        description: {
+          type: "string",
+          description: "Customer-facing note rendered on the quote."
+        },
+        status: {
+          type: "string",
+          enum: ["draft"],
+          default: "draft",
+          description: "Only 'draft' is allowed."
+        },
+        validUntil: {
+          type: "string",
+          description: "ISO date the quote is valid until (e.g. 2026-07-31)."
+        },
+        lineItems: {
+          type: "array",
+          description: "Line items. Each: { name?, quantity?, unit?, price?, productId? }. With productId the catalog product is snapshotted onto the line item (name/price overridable).",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              quantity: { type: "number" },
+              unit: { type: "string" },
+              price: { type: "number", description: "Unit price excl. VAT" },
+              productId: {
+                type: "string",
+                description: "Catalog product ID to snapshot onto this item"
+              }
+            }
+          }
+        }
+      },
+      required: ["customerId"]
+    }
+  },
+  {
+    name: "update-quote",
+    description: "Update a DRAFT quote/offerte. Only quotes still in status `draft` can be changed \u2014 sent/accepted/rejected/expired quotes are immutable here so their product snapshots stay reproducible. Status can only stay `draft`; approve/send/accept/reject/expire are blocked and must be done manually from the dashboard. Provide `lineItems` to REPLACE all items (totals recomputed; productId items are re-snapshotted).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        id: { type: "string", description: "Quote ID (UUID)" },
+        title: { type: "string" },
+        description: {
+          type: ["string", "null"],
+          description: "Customer-facing note; null clears it."
+        },
+        validUntil: {
+          type: ["string", "null"],
+          description: "ISO date; null clears it."
+        },
+        status: {
+          type: "string",
+          enum: ["draft"],
+          description: "Only 'draft' is allowed."
+        },
+        lineItems: {
+          type: "array",
+          description: "Replaces ALL line items. Each: { name?, quantity?, unit?, price?, productId? }.",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string" },
+              quantity: { type: "number" },
+              unit: { type: "string" },
+              price: { type: "number", description: "Unit price excl. VAT" },
+              productId: { type: "string" }
+            }
+          }
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "add-product-to-quote",
+    description: "Add a catalog product as a new line item on a DRAFT quote, storing an immutable product snapshot (name, description, unitPrice, currency, vatRate, unit, metadata) on the line item. Only works on `draft` quotes. Later catalog product edits never mutate this quote \u2014 it keeps its snapshot. Recomputes the quote totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        quoteId: { type: "string", description: "Quote ID (UUID)" },
+        productId: {
+          type: "string",
+          description: "Catalog product ID (see get-products)"
+        },
+        quantity: { type: "number", default: 1 },
+        customDescription: {
+          type: "string",
+          description: "Overrides the snapshotted product name on this line item."
+        },
+        customPrice: {
+          type: "number",
+          description: "Overrides the snapshotted unit price (excl. VAT)."
+        }
+      },
+      required: ["quoteId", "productId"]
+    }
+  },
   {
     name: "log-hours",
     description: "Analyze current chat conversation and log hours as draft tracker entry. AI analyzes chat context to estimate hours as a senior developer would (without AI assistance). Cursor AI matches workspace name to correct project from list (optional).",
@@ -106408,6 +106751,167 @@ var TOOLS = [
       required: ["workDescription", "estimatedHours"]
     }
   },
+  {
+    name: "get-trips",
+    description: "List trips / kilometer registration entries (rides) scoped to your provider team(s), with optional filters by period (dateFrom/dateTo), user, project, customer, trip type (business/private), billing type, and invoiced status. Returns each trip's id, date, start/end location, distance (km), odometer readings, trip type, billing type, rate/amount, linked user/project/customer/invoice/vehicle, plus aggregate business/private/total km and total amount.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        dateFrom: {
+          type: "string",
+          description: "Inclusive period start (YYYY-MM-DD)."
+        },
+        dateTo: {
+          type: "string",
+          description: "Inclusive period end (YYYY-MM-DD)."
+        },
+        userId: { type: "string", description: "Filter by driver user ID" },
+        projectId: { type: "string", description: "Filter by project ID" },
+        customerId: { type: "string", description: "Filter by customer ID" },
+        tripType: { type: "string", enum: ["private", "business"] },
+        billingType: {
+          type: "string",
+          enum: ["not_billable", "per_km", "per_trip"]
+        },
+        isInvoiced: {
+          type: "boolean",
+          description: "Filter by invoiced status"
+        },
+        pageSize: { type: "number", default: 50, maximum: 200 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create-trip",
+    description: "Record a confirmed trip (kilometer registration entry) for the API key user in the resolved provider team. When `amount` is omitted it is auto-derived: distance * rate for billingType per_km, or the flat rate for per_trip. Distances/odometer are in km. Validates project/customer/vehicle access. Use get-projects/get-customers/get-vehicles to resolve ids first. Duplicate detection: a trip with the same driver, date and route (+ project/customer when given) is refused unless allowDuplicate: true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        date: { type: "string", description: "Trip date (YYYY-MM-DD)" },
+        startLocation: { type: "string" },
+        endLocation: { type: "string" },
+        tripType: { type: "string", enum: ["private", "business"] },
+        distance: { type: "number", description: "Distance in km" },
+        odometerStart: { type: "number" },
+        odometerEnd: { type: "number" },
+        projectId: { type: "string" },
+        customerId: { type: "string" },
+        billingType: {
+          type: "string",
+          enum: ["not_billable", "per_km", "per_trip"],
+          default: "not_billable"
+        },
+        rate: { type: "number", description: "Rate per km (per_km) or per trip (per_trip)" },
+        amount: {
+          type: "number",
+          description: "Total amount. Auto-derived from distance*rate (per_km) or rate (per_trip) when omitted."
+        },
+        notes: { type: "string" },
+        vehicleId: { type: "string" },
+        snapshotId: { type: "string" },
+        allowDuplicate: {
+          type: "boolean",
+          description: "Set true to skip duplicate detection and record a second trip with the same driver/date/route."
+        }
+      },
+      required: ["date", "startLocation", "endLocation", "tripType"]
+    }
+  },
+  {
+    name: "update-trip",
+    description: "Update an existing trip and/or (re)link it to a project, customer or invoice. Only provided fields change. SAFETY: once a trip is invoiced (isInvoiced true or invoiceId set), the financial/distance fields (date, locations, tripType, distance, odometer, billingType, rate, amount, invoiceId, isInvoiced) are LOCKED \u2014 the call is rejected unless you pass allowInvoicedOverride: true. Project/customer/notes/vehicle links remain editable regardless. Setting invoiceId also marks the trip invoiced (pass invoiceId: null to unlink). Find trip ids via get-trips.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        id: { type: "string", description: "Trip ID (UUID)" },
+        date: { type: "string", description: "YYYY-MM-DD" },
+        startLocation: { type: "string" },
+        endLocation: { type: "string" },
+        tripType: { type: "string", enum: ["private", "business"] },
+        distance: { type: ["number", "null"], description: "Distance in km" },
+        odometerStart: { type: ["number", "null"] },
+        odometerEnd: { type: ["number", "null"] },
+        projectId: { type: ["string", "null"] },
+        customerId: { type: ["string", "null"] },
+        vehicleId: { type: ["string", "null"] },
+        notes: { type: ["string", "null"] },
+        billingType: {
+          type: "string",
+          enum: ["not_billable", "per_km", "per_trip"]
+        },
+        rate: { type: ["number", "null"] },
+        amount: {
+          type: ["number", "null"],
+          description: "Total amount. Recomputed from distance*rate/rate when distance/rate/billingType change and amount is omitted."
+        },
+        linkedTripId: {
+          type: ["string", "null"],
+          description: "Paired return-trip id, or null to unlink."
+        },
+        invoiceId: {
+          type: ["string", "null"],
+          description: "Invoice ID to link this trip to (see get-invoices), or null to unlink. Marks the trip invoiced."
+        },
+        isInvoiced: { type: "boolean" },
+        allowInvoicedOverride: {
+          type: "boolean",
+          description: "Set true to edit locked financial/distance fields on an already-invoiced trip."
+        }
+      },
+      required: ["id"]
+    }
+  },
+  {
+    name: "get-vehicles",
+    description: "List the team's vehicles used for trip / kilometer registration. Returns id, name, license plate and current odometer (km). Use the ids with create-trip / update-trip.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        q: { type: "string", description: "Search query for vehicle name" },
+        pageSize: { type: "number", default: 50, maximum: 200 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get-trip-templates",
+    description: "List reusable trip templates (saved start/end + billing defaults) for quick trip entry. Defaults to the API key user's templates; pass userId 'all' to list every team member's templates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        userId: {
+          type: "string",
+          description: "User whose templates to list (defaults to the API key user). Pass 'all' for every team member."
+        },
+        pageSize: { type: "number", default: 50, maximum: 200 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get-frequent-trips-for-project",
+    description: "Return the most frequent (start, end, type) trip combinations a user drove for a project in the last `daysBack` days, with counts, average distance and last-used date. Useful to suggest a standard ride before calling create-trip.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        projectId: { type: "string", description: "Project ID (UUID)" },
+        userId: {
+          type: "string",
+          description: "Driver user ID (defaults to the API key user)"
+        },
+        daysBack: { type: "number", default: 60 },
+        limit: { type: "number", default: 5, maximum: 25 }
+      },
+      required: ["projectId"]
+    }
+  },
   {
     name: "get-github-file",
     description: "Get the contents of a specific file from a GitHub repository. Use this after finding relevant files to read their full content.",
@@ -107148,21 +107652,61 @@ async function syncTicketDeadline(teamId, ticket, dueDate) {
   return null;
 }
 
+// src/tools/customer-cleanup-util.ts
+var CUSTOMER_STATUS_FILTERS = [
+  "active",
+  "archived",
+  "all"
+];
+var DEPENDENCY_LABELS = {
+  projects: "project(s)",
+  tickets: "ticket(s)",
+  invoices: "invoice(s)",
+  quotations: "quotation(s)",
+  documents: "document(s)",
+  timesheetEvents: "agenda/time entr(ies)",
+  timesheetTemplates: "timesheet template(s)",
+  trips: "trip(s)",
+  tripTemplates: "trip template(s)"
+};
+function totalCustomerDependencies(counts) {
+  return counts.projects + counts.tickets + counts.invoices + counts.quotations + counts.documents + counts.timesheetEvents + counts.timesheetTemplates + counts.trips + counts.tripTemplates;
+}
+function isCustomerEmpty(counts) {
+  return totalCustomerDependencies(counts) === 0;
+}
+function formatCustomerDependencies(counts) {
+  const parts = Object.keys(DEPENDENCY_LABELS).filter((key) => counts[key] > 0).map((key) => `${counts[key]} ${DEPENDENCY_LABELS[key]}`);
+  return parts.length > 0 ? parts.join(", ") : "no dependencies";
+}
+function findExactCustomerMatches(customers2, opts) {
+  const wantName = opts.name?.trim().toLowerCase();
+  const wantEmail = opts.email?.trim().toLowerCase();
+  if (!wantName && !wantEmail) return [];
+  return customers2.filter((c6) => {
+    const nameOk = wantName === void 0 || (c6.name ?? "").trim().toLowerCase() === wantName;
+    const emailOk = wantEmail === void 0 || (c6.email ?? "").trim().toLowerCase() === wantEmail;
+    return nameOk && emailOk;
+  });
+}
+
 // src/tools/customers.ts
+function textResponse(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
 async function handleGetCustomers(input) {
   const { q: q3, pageSize = 20 } = input;
+  const status = input.status ?? "active";
+  if (!CUSTOMER_STATUS_FILTERS.includes(status)) {
+    return textResponse(
+      `Error: invalid status "${status}". Allowed: ${CUSTOMER_STATUS_FILTERS.join(", ")}.`
+    );
+  }
   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."
-        }
-      ]
-    };
+    return textResponse("No customers found or no access to any customers.");
   }
   const filters = [inArray(schema_exports.customers.id, customerIds)];
   if (q3) {
@@ -107174,54 +107718,332 @@ async function handleGetCustomers(input) {
       )
     );
   }
+  if (status === "active") {
+    filters.push(
+      or(
+        eq(schema_exports.customers.isArchived, false),
+        sql`${schema_exports.customers.isArchived} IS NULL`
+      )
+    );
+  } else if (status === "archived") {
+    filters.push(eq(schema_exports.customers.isArchived, true));
+  }
   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,
+    phone: schema_exports.customers.phone,
+    status: schema_exports.customers.status,
+    isArchived: schema_exports.customers.isArchived,
     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:
+  return textResponse(
+    `Found ${rows.length} customer(s)${status !== "all" ? ` (status: ${status})` : ""}:
 
 ${rows.map(
-          (c6) => `**${c6.name}**
+      (c6) => `**${c6.name}** (ID: ${c6.id})${c6.isArchived ? " \u2014 ARCHIVED" : ""}
 ${c6.email ? `Email: ${c6.email}
 ` : ""}${c6.website ? `Website: ${c6.website}
+` : ""}${c6.phone ? `Phone: ${c6.phone}
+` : ""}${c6.status ? `Status: ${c6.status}
 ` : ""}Created: ${new Date(c6.createdAt).toLocaleDateString()}
 `
-        ).join("\n") || "No customers found."}`
-      }
-    ]
-  };
+    ).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({
+  const [created] = 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!**
+  }).returning({ id: schema_exports.customers.id });
+  return textResponse(
+    `\u2705 **Customer Created Successfully!**
 
 Name: ${name21}
-${email5 ? `Email: ${email5}
+${created ? `ID: ${created.id}
+` : ""}${email5 ? `Email: ${email5}
 ` : ""}${website ? `Website: ${website}
 ` : ""}`
-      }
-    ]
+  );
+}
+async function loadAccessibleCustomer(customerId, teamId) {
+  const accessibleIds = await getAccessibleCustomerIds(teamId);
+  if (!accessibleIds.includes(customerId)) return null;
+  const [row] = await db.select({
+    id: schema_exports.customers.id,
+    name: schema_exports.customers.name,
+    email: schema_exports.customers.email,
+    website: schema_exports.customers.website,
+    status: schema_exports.customers.status,
+    isArchived: schema_exports.customers.isArchived
+  }).from(schema_exports.customers).where(eq(schema_exports.customers.id, customerId)).limit(1);
+  return row ?? null;
+}
+async function resolveTargetCustomer(teamId, opts) {
+  if (opts.customerId) {
+    const customer2 = await loadAccessibleCustomer(opts.customerId, teamId);
+    if (!customer2) {
+      return {
+        ok: false,
+        response: textResponse(
+          `Customer ${opts.customerId} not found, or this team cannot access it.`
+        )
+      };
+    }
+    return { ok: true, customer: customer2 };
+  }
+  if (!opts.customerName && !opts.email) {
+    return {
+      ok: false,
+      response: textResponse(
+        "Provide a `customerId`, or an exact `customerName` and/or `email` to identify the customer."
+      )
+    };
+  }
+  const accessibleIds = await getAccessibleCustomerIds(teamId);
+  if (accessibleIds.length === 0) {
+    return {
+      ok: false,
+      response: textResponse("No customers found or no access to any customers.")
+    };
+  }
+  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,
+    status: schema_exports.customers.status,
+    isArchived: schema_exports.customers.isArchived
+  }).from(schema_exports.customers).where(inArray(schema_exports.customers.id, accessibleIds));
+  const lite = rows.map((r6) => ({
+    id: r6.id,
+    name: r6.name,
+    email: r6.email
+  }));
+  const matches = findExactCustomerMatches(lite, {
+    name: opts.customerName,
+    email: opts.email
+  });
+  if (matches.length === 0) {
+    const criteria = [
+      opts.customerName ? `name "${opts.customerName}"` : null,
+      opts.email ? `email "${opts.email}"` : null
+    ].filter(Boolean).join(" and ");
+    return {
+      ok: false,
+      response: textResponse(
+        `No customer found with an exact ${criteria}. Use get-customers to find the exact name/email or the customer id.`
+      )
+    };
+  }
+  if (matches.length > 1) {
+    const list = matches.map((m4) => `- ${m4.name ?? "(no name)"} (ID: ${m4.id}, email: ${m4.email ?? "\u2014"})`).join("\n");
+    return {
+      ok: false,
+      response: textResponse(
+        `\u{1F6AB} Refusing to act: ${matches.length} customers match that name/email. Re-run with an explicit \`customerId\`.
+
+Matches:
+${list}`
+      )
+    };
+  }
+  const customer = rows.find((r6) => r6.id === matches[0].id);
+  return { ok: true, customer };
+}
+async function requireTeamOwner(teamId, userId) {
+  const [membership] = await db.select({ role: schema_exports.usersOnTeam.role }).from(schema_exports.usersOnTeam).where(
+    and(
+      eq(schema_exports.usersOnTeam.userId, userId),
+      eq(schema_exports.usersOnTeam.teamId, teamId)
+    )
+  ).limit(1);
+  return membership?.role === "owner" ? null : textResponse(
+    "Only team owners can hard-delete a customer. Ask a team owner to run this action (or use archive-customer, which any team member can do)."
+  );
+}
+async function countCustomerDependencies(customerId) {
+  const countRows = (table) => db.select({ c: sql`count(*)::int` }).from(table).where(eq(table.customerId, customerId)).then((r6) => r6[0]?.c ?? 0);
+  const [
+    projects2,
+    tickets3,
+    invoices2,
+    quotations2,
+    documents2,
+    timesheetEvents2,
+    timesheetTemplates2,
+    trips2,
+    tripTemplates2
+  ] = await Promise.all([
+    countRows(schema_exports.projects),
+    countRows(schema_exports.tickets),
+    countRows(schema_exports.invoices),
+    countRows(schema_exports.quotations),
+    countRows(schema_exports.documents),
+    countRows(schema_exports.timesheetEvents),
+    countRows(schema_exports.timesheetTemplates),
+    countRows(schema_exports.trips),
+    countRows(schema_exports.tripTemplates)
+  ]);
+  return {
+    projects: projects2,
+    tickets: tickets3,
+    invoices: invoices2,
+    quotations: quotations2,
+    documents: documents2,
+    timesheetEvents: timesheetEvents2,
+    timesheetTemplates: timesheetTemplates2,
+    trips: trips2,
+    tripTemplates: tripTemplates2
   };
 }
+async function handleUpdateCustomer(input) {
+  const { customerId } = input;
+  if (!customerId) return textResponse("Error: `customerId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const existing = await loadAccessibleCustomer(customerId, resolved.teamId);
+  if (!existing) {
+    return textResponse(
+      `Customer ${customerId} not found, or this team cannot access it.`
+    );
+  }
+  const set3 = {};
+  const assign = (key, column) => {
+    if (input[key] !== void 0) set3[column] = input[key];
+  };
+  assign("name", "name");
+  assign("email", "email");
+  assign("website", "website");
+  assign("phone", "phone");
+  assign("companyName", "companyName");
+  assign("billingEmail", "billingEmail");
+  assign("vatNumber", "vatNumber");
+  assign("contact", "contact");
+  assign("note", "note");
+  assign("addressLine1", "addressLine1");
+  assign("addressLine2", "addressLine2");
+  assign("city", "city");
+  assign("state", "state");
+  assign("zip", "zip");
+  assign("country", "country");
+  assign("countryCode", "countryCode");
+  assign("status", "status");
+  assign("isArchived", "isArchived");
+  if (Object.keys(set3).length === 0) {
+    return textResponse(
+      "No editable fields provided. Pass at least one of: name, email, website, phone, companyName, billingEmail, vatNumber, contact, note, address fields, status, or isArchived."
+    );
+  }
+  if (set3.email === null || set3.email === "") {
+    return textResponse("Error: `email` cannot be empty (the column is required).");
+  }
+  set3.updatedAt = sql`now()`;
+  await db.update(schema_exports.customers).set(set3).where(eq(schema_exports.customers.id, customerId));
+  const [updated] = await db.select({
+    id: schema_exports.customers.id,
+    name: schema_exports.customers.name,
+    email: schema_exports.customers.email,
+    website: schema_exports.customers.website,
+    phone: schema_exports.customers.phone,
+    status: schema_exports.customers.status,
+    isArchived: schema_exports.customers.isArchived
+  }).from(schema_exports.customers).where(eq(schema_exports.customers.id, customerId)).limit(1);
+  if (!updated) return textResponse(`Failed to update customer ${customerId}.`);
+  const lines = [
+    "\u2705 **Customer Updated**",
+    "",
+    `Name: ${updated.name} (ID: ${updated.id})`
+  ];
+  if (updated.email) lines.push(`Email: ${updated.email}`);
+  if (updated.website) lines.push(`Website: ${updated.website}`);
+  if (updated.phone) lines.push(`Phone: ${updated.phone}`);
+  if (updated.status) lines.push(`Status: ${updated.status}`);
+  lines.push(`Archived: ${updated.isArchived ? "yes" : "no"}`);
+  return textResponse(lines.join("\n"));
+}
+async function handleArchiveCustomer(input) {
+  const { reason } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const target = await resolveTargetCustomer(resolved.teamId, {
+    customerId: input.customerId,
+    customerName: input.customerName,
+    email: input.email
+  });
+  if (!target.ok) return target.response;
+  const customer = target.customer;
+  if (customer.isArchived) {
+    return textResponse(
+      `Customer "${customer.name}" (${customer.id}) is already archived.`
+    );
+  }
+  const archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await db.update(schema_exports.customers).set({ isArchived: true, status: "inactive", updatedAt: sql`now()` }).where(eq(schema_exports.customers.id, customer.id));
+  return textResponse(
+    `\u2705 **Customer archived**
+
+Name: ${customer.name}
+ID: ${customer.id}
+${customer.email ? `Email: ${customer.email}
+` : ""}Action: archived (soft, reversible)
+Status: inactive
+Timestamp: ${archivedAt}
+${reason ? `Reason: ${reason}
+` : ""}
+Archived customers are hidden from get-customers by default (pass status: 'archived' or 'all' to see them). No projects, tickets, invoices or other data were touched. Reactivate later with update-customer (isArchived: false).`
+  );
+}
+async function handleDeleteCustomer(input) {
+  const ctx = getAuthContext();
+  const { confirmEmptyOnly } = input;
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const ownerError = await requireTeamOwner(resolved.teamId, ctx.userId);
+  if (ownerError) return ownerError;
+  const target = await resolveTargetCustomer(resolved.teamId, {
+    customerId: input.customerId,
+    customerName: input.customerName,
+    email: input.email
+  });
+  if (!target.ok) return target.response;
+  const customer = target.customer;
+  const deps = await countCustomerDependencies(customer.id);
+  const summary = formatCustomerDependencies(deps);
+  if (!isCustomerEmpty(deps)) {
+    return textResponse(
+      `\u{1F6AB} **Delete blocked** \u2014 customer "${customer.name}" (${customer.id}) is not empty.
+
+Dependencies: ${summary}.
+
+A hard delete would cascade-delete its projects and orphan the rest, so it is not allowed. Use archive-customer instead to safely retire this customer (reversible, keeps all data).`
+    );
+  }
+  if (confirmEmptyOnly !== true) {
+    return textResponse(
+      `Customer "${customer.name}" (${customer.id}) has no projects, tickets, invoices, quotations, documents, time entries, or trips and can be safely deleted. This is a permanent hard delete. Re-run delete-customer with confirmEmptyOnly: true to proceed (or use archive-customer to keep the record).`
+    );
+  }
+  await db.delete(schema_exports.customers).where(eq(schema_exports.customers.id, customer.id));
+  return textResponse(
+    `\u2705 **Customer deleted**
+
+Name: ${customer.name}
+ID: ${customer.id}
+${customer.email ? `Email: ${customer.email}
+` : ""}Action: hard delete (empty customer)
+Status: deleted
+Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+The customer had no projects, tickets, invoices, quotations, documents, time entries, or trips. Any customer-scoped config (tags, shares, domain join requests, portal tokens) was removed with it.`
+  );
+}
 
 // ../document/src/humanizer/rules.ts
 var REPLACEMENTS = [
@@ -107985,7 +108807,7 @@ async function applyHumanizer(blocks, mode) {
     for (const change of rules.report) {
       byRule.set(change.rule, (byRule.get(change.rule) ?? 0) + 1);
     }
-    const ruleSummary = [...byRule.entries()].map(([rule, count]) => `${rule} \xD7${count}`).join(", ");
+    const ruleSummary = [...byRule.entries()].map(([rule, count2]) => `${rule} \xD7${count2}`).join(", ");
     lines.push(
       `Humanizer (rules): ${rules.report.length} aanpassing(en) \u2014 ${ruleSummary}.`
     );
@@ -112565,10 +113387,59 @@ The document can now be selected as a PDF attachment when sending this invoice f
   };
 }
 
+// src/tools/project-cleanup-util.ts
+var PROJECT_STATUS_FILTERS = [
+  "active",
+  "archived",
+  "all"
+];
+var DEPENDENCY_LABELS2 = {
+  tickets: "ticket(s)",
+  timesheetEvents: "agenda/time entr(ies)",
+  timesheetTemplates: "timesheet template(s)",
+  trips: "trip(s)",
+  tripTemplates: "trip template(s)"
+};
+function getProjectArchiveState(settings) {
+  const obj = settings && typeof settings === "object" && !Array.isArray(settings) ? settings : {};
+  const archivedAt = typeof obj.archivedAt === "string" && obj.archivedAt.trim().length > 0 ? obj.archivedAt : null;
+  const archiveReason = typeof obj.archiveReason === "string" && obj.archiveReason.trim().length > 0 ? obj.archiveReason : null;
+  return { archived: archivedAt !== null, archivedAt, archiveReason };
+}
+function withArchiveSettings(settings, archivedAt, reason) {
+  const base = settings && typeof settings === "object" && !Array.isArray(settings) ? { ...settings } : {};
+  base.archivedAt = archivedAt;
+  if (reason && reason.trim().length > 0) {
+    base.archiveReason = reason.trim();
+  }
+  return base;
+}
+function totalProjectDependencies(counts) {
+  return counts.tickets + counts.timesheetEvents + counts.timesheetTemplates + counts.trips + counts.tripTemplates;
+}
+function isProjectEmpty(counts) {
+  return totalProjectDependencies(counts) === 0;
+}
+function formatProjectDependencies(counts) {
+  const parts = Object.keys(DEPENDENCY_LABELS2).filter((key) => counts[key] > 0).map((key) => `${counts[key]} ${DEPENDENCY_LABELS2[key]}`);
+  return parts.length > 0 ? parts.join(", ") : "no dependencies";
+}
+
 // src/tools/projects.ts
 async function handleGetProjects(input) {
   const ctx = getAuthContext();
   const { customerId, q: q3, pageSize = 20 } = input;
+  const status = input.status ?? "active";
+  if (!PROJECT_STATUS_FILTERS.includes(status)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: invalid status "${status}". Allowed: ${PROJECT_STATUS_FILTERS.join(", ")}.`
+        }
+      ]
+    };
+  }
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const projectIds = await getAccessibleProjectIds(ctx.userId, resolved.teamId);
@@ -112585,25 +113456,33 @@ async function handleGetProjects(input) {
   const filters = [inArray(schema_exports.projects.id, projectIds)];
   if (customerId) filters.push(eq(schema_exports.projects.customerId, customerId));
   if (q3) filters.push(ilike(schema_exports.projects.name, `%${q3}%`));
+  if (status === "active") {
+    filters.push(sql`${schema_exports.projects.settings} ->> 'archivedAt' IS NULL`);
+  } else if (status === "archived") {
+    filters.push(sql`${schema_exports.projects.settings} ->> 'archivedAt' IS NOT NULL`);
+  }
   const rows = await db.select({
     id: schema_exports.projects.id,
     name: schema_exports.projects.name,
     description: schema_exports.projects.description,
     customerId: schema_exports.projects.customerId,
-    createdAt: schema_exports.projects.createdAt
+    createdAt: schema_exports.projects.createdAt,
+    settings: schema_exports.projects.settings
   }).from(schema_exports.projects).where(and(...filters)).orderBy(asc(schema_exports.projects.name)).limit(Math.min(pageSize, 100));
   return {
     content: [
       {
         type: "text",
-        text: `Found ${rows.length} projects:
+        text: `Found ${rows.length} project(s)${status !== "all" ? ` (status: ${status})` : ""}:
 
-${rows.map(
-          (p3) => `**${p3.name}** (ID: ${p3.id})
+${rows.map((p3) => {
+          const archive = getProjectArchiveState(p3.settings);
+          return `**${p3.name}** (ID: ${p3.id})${archive.archived ? " \u2014 ARCHIVED" : ""}
 ${p3.description ? `Description: ${p3.description}
 ` : ""}Created: ${new Date(p3.createdAt).toLocaleDateString()}
-`
-        ).join("\n") || "No projects found."}`
+${archive.archived ? `Archived: ${archive.archivedAt}${archive.archiveReason ? ` (${archive.archiveReason})` : ""}
+` : ""}`;
+        }).join("\n") || "No projects found."}`
       }
     ]
   };
@@ -112631,21 +113510,21 @@ ${description ? `Description: ${description}
     ]
   };
 }
-function textResponse(text3) {
+function textResponse2(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function memberLabel(m4) {
   return m4.fullName || m4.email || m4.userId;
 }
 var OWNER_REQUIRED = "Only team owners can manage project members. Ask a team owner to run this action (or use an owner's API key).";
-async function requireTeamOwner(teamId, userId) {
+async function requireTeamOwner2(teamId, userId) {
   const [membership] = await db.select({ role: schema_exports.usersOnTeam.role }).from(schema_exports.usersOnTeam).where(
     and(
       eq(schema_exports.usersOnTeam.userId, userId),
       eq(schema_exports.usersOnTeam.teamId, teamId)
     )
   ).limit(1);
-  return membership?.role === "owner" ? null : textResponse(OWNER_REQUIRED);
+  return membership?.role === "owner" ? null : textResponse2(OWNER_REQUIRED);
 }
 async function setProjectMemberAccess(params) {
   const { projectId, teamId, memberIds, createdBy } = params;
@@ -112749,7 +113628,7 @@ async function resolveTeamMember(teamId, opts) {
     if (!match) {
       return {
         ok: false,
-        response: textResponse(
+        response: textResponse2(
           `User ${opts.userId} is not a member of this team. Call get-project-members to see the team roster.`
         )
       };
@@ -112762,7 +113641,7 @@ async function resolveTeamMember(teamId, opts) {
     if (matches.length === 0) {
       return {
         ok: false,
-        response: textResponse(
+        response: textResponse2(
           `No team member found with email "${opts.email}". Call get-project-members to see the team roster.`
         )
       };
@@ -112770,7 +113649,7 @@ async function resolveTeamMember(teamId, opts) {
     if (matches.length > 1) {
       return {
         ok: false,
-        response: textResponse(
+        response: textResponse2(
           `Multiple team members match email "${opts.email}". Pass an explicit userId instead.`
         )
       };
@@ -112779,7 +113658,7 @@ async function resolveTeamMember(teamId, opts) {
   }
   return {
     ok: false,
-    response: textResponse(
+    response: textResponse2(
       "Provide either a userId or an email to identify the member."
     )
   };
@@ -112828,7 +113707,7 @@ async function handleUpdateProject(input) {
   if (!resolved.ok) return resolved.response;
   const existing = await loadProjectInTeam(id, resolved.teamId);
   if (!existing) {
-    return textResponse(
+    return textResponse2(
       `Project ${id} not found, or it is not owned by this team.`
     );
   }
@@ -112843,7 +113722,7 @@ async function handleUpdateProject(input) {
       )
     ).limit(1);
     if (dupe) {
-      return textResponse(
+      return textResponse2(
         `A project named "${input.name}" already exists in this team. Choose a different name.`
       );
     }
@@ -112908,7 +113787,7 @@ async function handleUpdateProject(input) {
     customerName: schema_exports.customers.name
   }).from(schema_exports.projects).leftJoin(schema_exports.customers, eq(schema_exports.projects.customerId, schema_exports.customers.id)).where(eq(schema_exports.projects.id, id)).limit(1);
   if (!updated) {
-    return textResponse(`Failed to update project ${id}.`);
+    return textResponse2(`Failed to update project ${id}.`);
   }
   const lines = [
     "\u2705 **Project Updated**",
@@ -112926,7 +113805,7 @@ async function handleUpdateProject(input) {
   if (willRename) {
     lines.push("", "Note: tickets for this project were renumbered.");
   }
-  return textResponse(lines.join("\n"));
+  return textResponse2(lines.join("\n"));
 }
 async function handleGetProjectMembers(input) {
   const { projectId } = input;
@@ -112934,7 +113813,7 @@ async function handleGetProjectMembers(input) {
   if (!resolved.ok) return resolved.response;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse(
+    return textResponse2(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -112963,7 +113842,7 @@ async function handleGetProjectMembers(input) {
     return `- ${memberLabel(m4)} (userId: ${m4.userId}, role: ${m4.role ?? "member"}) \u2014 ${access}`;
   }).join("\n");
   const note = state2.projectMemberIds.size === 0 ? "No members are explicitly assigned to this project, so every owner and every unrestricted member can see it." : `${state2.projectMemberIds.size} member(s) are explicitly assigned to this project.`;
-  return textResponse(
+  return textResponse2(
     `**Project members for "${project.name}"** (ID: ${project.id})
 
 ${note}
@@ -112980,11 +113859,11 @@ async function handleSetProjectMembers(input) {
   const { projectId } = input;
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
-  const ownerError = await requireTeamOwner(resolved.teamId, ctx.userId);
+  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse(
+    return textResponse2(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -113022,7 +113901,7 @@ async function handleSetProjectMembers(input) {
 
 \u26A0\uFE0F ${names} previously had no restrictions (could see all projects). They are now restricted to only the projects explicitly assigned to them.`;
   }
-  return textResponse(
+  return textResponse2(
     `\u2705 **Project members updated**
 
 Members with explicit access to this project:
@@ -113034,11 +113913,11 @@ async function handleAddProjectMember(input) {
   const { projectId } = input;
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
-  const ownerError = await requireTeamOwner(resolved.teamId, ctx.userId);
+  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse(
+    return textResponse2(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -113049,7 +113928,7 @@ async function handleAddProjectMember(input) {
   if (!member2.ok) return member2.response;
   const state2 = await getProjectAccessState(resolved.teamId, projectId);
   if (state2.projectMemberIds.has(member2.member.userId)) {
-    return textResponse(
+    return textResponse2(
       `${memberLabel(member2.member)} already has explicit access to this project.`
     );
   }
@@ -113064,18 +113943,18 @@ async function handleAddProjectMember(input) {
   if (wasUnrestricted) {
     text3 += "\n\n\u26A0\uFE0F This member previously had no access restrictions (they could see all projects). They are now restricted to ONLY the projects explicitly assigned to them. Grant any other projects they still need with add-project-member, or remove all their assignments to restore full visibility.";
   }
-  return textResponse(text3);
+  return textResponse2(text3);
 }
 async function handleRemoveProjectMember(input) {
   const ctx = getAuthContext();
   const { projectId } = input;
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
-  const ownerError = await requireTeamOwner(resolved.teamId, ctx.userId);
+  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse(
+    return textResponse2(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -113086,7 +113965,7 @@ async function handleRemoveProjectMember(input) {
   if (!member2.ok) return member2.response;
   const state2 = await getProjectAccessState(resolved.teamId, projectId);
   if (!state2.projectMemberIds.has(member2.member.userId)) {
-    return textResponse(
+    return textResponse2(
       `${memberLabel(member2.member)} has no explicit assignment to this project; nothing to remove.`
     );
   }
@@ -113102,7 +113981,109 @@ async function handleRemoveProjectMember(input) {
   if ((state2.rowCountByUser.get(member2.member.userId) ?? 0) <= 1) {
     text3 += "\n\nThis was the member's last project assignment, so their access restrictions were cleared \u2014 they can see all projects in the team again (default behavior).";
   }
-  return textResponse(text3);
+  return textResponse2(text3);
+}
+async function loadProjectForCleanup(projectId, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [row] = await db.select({
+    id: schema_exports.projects.id,
+    name: schema_exports.projects.name,
+    teamId: schema_exports.projects.teamId,
+    settings: schema_exports.projects.settings
+  }).from(schema_exports.projects).where(eq(schema_exports.projects.id, projectId)).limit(1);
+  if (!row || !row.teamId || !accessibleTeamIds.includes(row.teamId)) {
+    return null;
+  }
+  return { id: row.id, name: row.name, teamId: row.teamId, settings: row.settings };
+}
+async function countProjectDependencies(projectId) {
+  const countRows = (table) => db.select({ c: sql`count(*)::int` }).from(table).where(eq(table.projectId, projectId)).then((r6) => r6[0]?.c ?? 0);
+  const [tickets3, timesheetEvents2, timesheetTemplates2, trips2, tripTemplates2] = await Promise.all([
+    countRows(schema_exports.tickets),
+    countRows(schema_exports.timesheetEvents),
+    countRows(schema_exports.timesheetTemplates),
+    countRows(schema_exports.trips),
+    countRows(schema_exports.tripTemplates)
+  ]);
+  return { tickets: tickets3, timesheetEvents: timesheetEvents2, timesheetTemplates: timesheetTemplates2, trips: trips2, tripTemplates: tripTemplates2 };
+}
+async function handleArchiveProject(input) {
+  const { projectId, reason } = input;
+  if (!projectId) return textResponse2("Error: `projectId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const project = await loadProjectForCleanup(projectId, resolved.teamId);
+  if (!project) {
+    return textResponse2(
+      `Project ${projectId} not found, or it is not owned by this team.`
+    );
+  }
+  const state2 = getProjectArchiveState(project.settings);
+  if (state2.archived) {
+    return textResponse2(
+      `Project "${project.name}" (${project.id}) is already archived${state2.archivedAt ? ` (since ${state2.archivedAt})` : ""}.`
+    );
+  }
+  const archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nextSettings = withArchiveSettings(project.settings, archivedAt, reason);
+  await db.update(schema_exports.projects).set({ settings: nextSettings, updatedAt: sql`now()` }).where(eq(schema_exports.projects.id, project.id));
+  return textResponse2(
+    `\u2705 **Project archived**
+
+Project: ${project.name}
+ID: ${project.id}
+Action: archived (soft, reversible)
+Status: archived
+Timestamp: ${archivedAt}
+${reason ? `Reason: ${reason}
+` : ""}
+Archived projects are hidden from get-projects by default (pass status: 'archived' or 'all' to see them). No tickets, hours, or other data were touched.
+
+Note: the archive flag is stored in \`projects.settings.archivedAt\`; the dashboard UI does not yet read it, so the project still appears there.`
+  );
+}
+async function handleDeleteProject(input) {
+  const ctx = getAuthContext();
+  const { projectId, confirmEmptyOnly } = input;
+  if (!projectId) return textResponse2("Error: `projectId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
+  if (ownerError) return ownerError;
+  const project = await loadProjectForCleanup(projectId, resolved.teamId);
+  if (!project) {
+    return textResponse2(
+      `Project ${projectId} not found, or it is not owned by this team.`
+    );
+  }
+  const deps = await countProjectDependencies(project.id);
+  const summary = formatProjectDependencies(deps);
+  if (!isProjectEmpty(deps)) {
+    return textResponse2(
+      `\u{1F6AB} **Delete blocked** \u2014 project "${project.name}" (${project.id}) is not empty.
+
+Dependencies: ${summary}.
+
+A hard delete would orphan these records, so it is not allowed. Use archive-project instead to safely retire this project (reversible, keeps all data).`
+    );
+  }
+  if (confirmEmptyOnly !== true) {
+    return textResponse2(
+      `Project "${project.name}" (${project.id}) has no dependencies and can be safely deleted. This is a permanent hard delete. Re-run delete-project with confirmEmptyOnly: true to proceed (or use archive-project to keep the record).`
+    );
+  }
+  await db.delete(schema_exports.projects).where(eq(schema_exports.projects.id, project.id));
+  return textResponse2(
+    `\u2705 **Project deleted**
+
+Project: ${project.name}
+ID: ${project.id}
+Action: hard delete (empty project)
+Status: deleted
+Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+The project had no tickets, hours, trips, or templates. Any project-scoped config (member access, tags, slack/github links, team rates) was removed with it.`
+  );
 }
 
 // src/tools/products.ts
@@ -113122,7 +114103,7 @@ var PRODUCT_COLUMNS = {
   createdAt: schema_exports.invoiceProducts.createdAt,
   updatedAt: schema_exports.invoiceProducts.updatedAt
 };
-function textResponse2(text3) {
+function textResponse3(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function formatPrice(p3) {
@@ -113143,14 +114124,14 @@ async function handleGetProducts(input) {
   const { q: q3, currency, pageSize = 20 } = input;
   const status = input.status ?? "active";
   if (!PRODUCT_STATUSES.includes(status)) {
-    return textResponse2(
+    return textResponse3(
       `Error: invalid status "${status}". Allowed: ${PRODUCT_STATUSES.join(", ")}.`
     );
   }
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse2("No accessible teams found.");
+    return textResponse3("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.invoiceProducts.teamId, scope.teamIds)];
   if (status === "active") {
@@ -113173,11 +114154,11 @@ async function handleGetProducts(input) {
     asc(schema_exports.invoiceProducts.name)
   ).limit(Math.min(pageSize, 100));
   if (rows.length === 0) {
-    return textResponse2(
+    return textResponse3(
       `No products found${status !== "all" ? ` (status: ${status})` : ""}.`
     );
   }
-  return textResponse2(
+  return textResponse3(
     `Found ${rows.length} product(s):
 
 ${rows.map(formatProduct).join("\n")}`
@@ -113185,11 +114166,11 @@ ${rows.map(formatProduct).join("\n")}`
 }
 async function handleGetProductById(input) {
   const { productId } = input;
-  if (!productId) return textResponse2("Error: `productId` is required.");
+  if (!productId) return textResponse3("Error: `productId` is required.");
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse2("No accessible teams found.");
+    return textResponse3("No accessible teams found.");
   }
   const [row] = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
     and(
@@ -113198,11 +114179,11 @@ async function handleGetProductById(input) {
     )
   ).limit(1);
   if (!row) {
-    return textResponse2(
+    return textResponse3(
       `Product ${productId} not found or you don't have access to it.`
     );
   }
-  return textResponse2(formatProduct(row));
+  return textResponse3(formatProduct(row));
 }
 async function loadProductInTeam(productId, teamId) {
   const accessibleTeamIds = await getAccessibleTeamIds(teamId);
@@ -113217,7 +114198,7 @@ async function loadProductInTeam(productId, teamId) {
 async function handleCreateProduct(input) {
   const { name: name21, description, price, currency, unit } = input;
   if (!name21 || name21.trim().length === 0) {
-    return textResponse2("Error: `name` is required.");
+    return textResponse3("Error: `name` is required.");
   }
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
@@ -113231,8 +114212,8 @@ async function handleCreateProduct(input) {
     isActive: true,
     lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
   }).returning(PRODUCT_COLUMNS);
-  if (!created) return textResponse2("Failed to create product.");
-  return textResponse2(
+  if (!created) return textResponse3("Failed to create product.");
+  return textResponse3(
     `\u2705 **Product created**
 
 ${formatProduct(created)}`
@@ -113240,19 +114221,19 @@ ${formatProduct(created)}`
 }
 async function handleUpdateProduct(input) {
   const { productId } = input;
-  if (!productId) return textResponse2("Error: `productId` is required.");
+  if (!productId) return textResponse3("Error: `productId` is required.");
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const existing = await loadProductInTeam(productId, resolved.teamId);
   if (!existing) {
-    return textResponse2(
+    return textResponse3(
       `Product ${productId} not found, or it is not owned by this team.`
     );
   }
   const updates = {};
   if (input.name !== void 0) {
     if (!input.name || input.name.trim().length === 0) {
-      return textResponse2("Error: `name` cannot be empty.");
+      return textResponse3("Error: `name` cannot be empty.");
     }
     updates.name = input.name.trim();
   }
@@ -113262,14 +114243,14 @@ async function handleUpdateProduct(input) {
   if (input.unit !== void 0) updates.unit = input.unit;
   if (input.isActive !== void 0) updates.isActive = input.isActive;
   if (Object.keys(updates).length === 0) {
-    return textResponse2(
+    return textResponse3(
       "No fields to update. Provide at least one of: name, description, price, currency, unit, isActive."
     );
   }
   updates.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const [updated] = await db.update(schema_exports.invoiceProducts).set(updates).where(eq(schema_exports.invoiceProducts.id, existing.id)).returning(PRODUCT_COLUMNS);
-  if (!updated) return textResponse2(`Failed to update product ${productId}.`);
-  return textResponse2(
+  if (!updated) return textResponse3(`Failed to update product ${productId}.`);
+  return textResponse3(
     `\u2705 **Product updated**
 
 ${formatProduct(updated)}
@@ -113278,23 +114259,23 @@ Note: this only affects future invoices/quotes. Existing documents keep their li
 }
 async function handleArchiveProduct(input) {
   const { productId, reason } = input;
-  if (!productId) return textResponse2("Error: `productId` is required.");
+  if (!productId) return textResponse3("Error: `productId` is required.");
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const existing = await loadProductInTeam(productId, resolved.teamId);
   if (!existing) {
-    return textResponse2(
+    return textResponse3(
       `Product ${productId} not found, or it is not owned by this team.`
     );
   }
   if (!existing.isActive) {
-    return textResponse2(
+    return textResponse3(
       `Product "${existing.name}" (${existing.id}) is already archived.`
     );
   }
   const [archived] = await db.update(schema_exports.invoiceProducts).set({ isActive: false, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(schema_exports.invoiceProducts.id, existing.id)).returning(PRODUCT_COLUMNS);
-  if (!archived) return textResponse2(`Failed to archive product ${productId}.`);
-  return textResponse2(
+  if (!archived) return textResponse3(`Failed to archive product ${productId}.`);
+  return textResponse3(
     `\u2705 **Product archived** (hidden from new invoices/quotes; existing documents are untouched).
 
 ${formatProduct(archived)}${reason ? `Reason: ${reason}
@@ -113302,6 +114283,514 @@ ${formatProduct(archived)}${reason ? `Reason: ${reason}
   );
 }
 
+// src/tools/quote-line-util.ts
+function round2(n3) {
+  return Math.round(n3 * 100) / 100;
+}
+function lineFinancials(quantity, price, defaults) {
+  const lineTotal = quantity * price;
+  return {
+    vat: defaults.includeVat ? round2(lineTotal * (defaults.vatRate / 100)) : void 0,
+    tax: defaults.includeTax ? round2(lineTotal * (defaults.taxRate / 100)) : void 0
+  };
+}
+function computeTotals(items, defaults) {
+  const subtotal = items.reduce(
+    (sum, i6) => sum + (i6.quantity || 0) * (i6.price || 0),
+    0
+  );
+  const vat = defaults.includeVat ? subtotal * (defaults.vatRate / 100) : 0;
+  const tax = defaults.includeTax ? subtotal * (defaults.taxRate / 100) : 0;
+  return {
+    subtotal: round2(subtotal),
+    vat: round2(vat),
+    tax: round2(tax),
+    amount: round2(subtotal + vat + tax)
+  };
+}
+function snapshotFromProduct(product, defaults, now2 = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    productId: product.id,
+    name: product.name,
+    description: product.description,
+    unitPrice: product.price,
+    currency: product.currency || defaults.currency,
+    vatRate: defaults.vatRate,
+    unit: product.unit,
+    capturedAt: now2(),
+    metadata: {
+      isConfigurable: product.isConfigurable,
+      options: product.options ?? null
+    }
+  };
+}
+function lineItemFromProduct(product, opts, defaults, now2 = () => (/* @__PURE__ */ new Date()).toISOString()) {
+  const quantity = opts.quantity ?? 1;
+  const price = opts.customPrice ?? product.price ?? 0;
+  const { vat, tax } = lineFinancials(quantity, price, defaults);
+  return {
+    name: opts.customDescription || product.name,
+    quantity,
+    unit: product.unit || void 0,
+    price,
+    vat,
+    tax,
+    productId: product.id,
+    productSnapshot: snapshotFromProduct(product, defaults, now2)
+  };
+}
+function templateDefaultsFromStored(template, currency) {
+  const t8 = template ?? {};
+  return {
+    currency: t8.currency || currency || "EUR",
+    vatRate: t8.vatRate ?? 21,
+    taxRate: t8.taxRate ?? 0,
+    includeVat: t8.includeVat ?? true,
+    includeTax: t8.includeTax ?? false,
+    includeDiscount: t8.includeDiscount ?? false,
+    includeDecimals: t8.includeDecimals ?? true,
+    includeUnits: t8.includeUnits ?? true,
+    includeQr: t8.includeQr ?? false,
+    size: t8.size || "a4",
+    fromDetails: null,
+    paymentDetails: null,
+    raw: t8
+  };
+}
+
+// src/tools/quotes.ts
+var QUOTE_STATUSES = [
+  "draft",
+  "sent",
+  "accepted",
+  "rejected",
+  "expired"
+];
+var SAFE_DRAFT_STATUSES = /* @__PURE__ */ new Set(["draft"]);
+function textResponse4(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+async function loadTemplateDefaults(teamId) {
+  const rows = await db.select().from(schema_exports.quotationTemplates).where(eq(schema_exports.quotationTemplates.teamId, teamId)).orderBy(desc(schema_exports.quotationTemplates.isDefault)).limit(1);
+  const t8 = rows[0];
+  return {
+    currency: t8?.currency || "EUR",
+    vatRate: t8?.vatRate ?? 21,
+    taxRate: t8?.taxRate ?? 0,
+    includeVat: t8?.includeVat ?? true,
+    includeTax: t8?.includeTax ?? false,
+    includeDiscount: t8?.includeDiscount ?? false,
+    includeDecimals: t8?.includeDecimals ?? true,
+    includeUnits: t8?.includeUnits ?? true,
+    includeQr: t8?.includeQr ?? false,
+    size: t8?.size || "a4",
+    fromDetails: t8?.fromDetails ?? null,
+    paymentDetails: t8?.paymentDetails ?? null,
+    raw: t8 ?? {}
+  };
+}
+function buildQuoteTemplate(defaults, titleOverride) {
+  const t8 = defaults.raw;
+  return {
+    currency: defaults.currency,
+    includeVat: defaults.includeVat,
+    includeTax: defaults.includeTax,
+    includeDiscount: defaults.includeDiscount,
+    includeDecimals: defaults.includeDecimals,
+    includeUnits: defaults.includeUnits,
+    includeQr: defaults.includeQr,
+    vatRate: defaults.vatRate,
+    taxRate: defaults.taxRate,
+    size: defaults.size,
+    locale: t8.locale || "nl",
+    timezone: "Europe/Amsterdam",
+    customerLabel: t8.customerLabel || "Klant",
+    title: titleOverride || t8.title || "Offerte",
+    fromLabel: t8.fromLabel || "Van",
+    quotationNoLabel: t8.quotationNoLabel || "Offerte nr.",
+    issueDateLabel: t8.issueDateLabel || "Datum",
+    validUntilLabel: t8.validUntilLabel || "Geldig tot",
+    descriptionLabel: t8.descriptionLabel || "Omschrijving",
+    priceLabel: t8.priceLabel || "Prijs",
+    quantityLabel: t8.quantityLabel || "Aantal",
+    totalLabel: t8.totalLabel || "Totaal",
+    totalSummaryLabel: t8.totalSummaryLabel || "Totaal",
+    vatLabel: t8.vatLabel || "BTW",
+    subtotalLabel: t8.subtotalLabel || "Subtotaal",
+    taxLabel: t8.taxLabel || "Belasting",
+    discountLabel: t8.discountLabel || "Korting",
+    paymentLabel: t8.paymentLabel || "Betaling",
+    noteLabel: t8.noteLabel || "Notitie",
+    logoUrl: t8.logoUrl ?? null,
+    dateFormat: t8.dateFormat || "dd/MM/yyyy"
+  };
+}
+async function nextQuotationNumber(teamId) {
+  const rows = await db.execute(
+    sql`SELECT get_next_quotation_number(${teamId}) AS next_quotation_number`
+  );
+  const value = rows[0]?.next_quotation_number;
+  if (!value) throw new Error("Failed to fetch next quotation number");
+  return value;
+}
+async function loadProductsInTeam(productIds, teamId) {
+  if (productIds.length === 0) return /* @__PURE__ */ new Map();
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const rows = await db.select({
+    id: schema_exports.invoiceProducts.id,
+    name: schema_exports.invoiceProducts.name,
+    description: schema_exports.invoiceProducts.description,
+    price: schema_exports.invoiceProducts.price,
+    currency: schema_exports.invoiceProducts.currency,
+    unit: schema_exports.invoiceProducts.unit,
+    isConfigurable: schema_exports.invoiceProducts.isConfigurable,
+    options: schema_exports.invoiceProducts.options
+  }).from(schema_exports.invoiceProducts).where(
+    and(
+      inArray(schema_exports.invoiceProducts.id, productIds),
+      inArray(schema_exports.invoiceProducts.teamId, accessibleTeamIds)
+    )
+  );
+  return new Map(rows.map((r6) => [r6.id, r6]));
+}
+async function resolveLineItems(inputs, defaults, teamId) {
+  const productIds = inputs.map((i6) => i6.productId).filter((id) => Boolean(id));
+  const products = await loadProductsInTeam([...new Set(productIds)], teamId);
+  const items = [];
+  for (const input of inputs) {
+    if (input.productId) {
+      const product = products.get(input.productId);
+      if (!product) {
+        return {
+          items: [],
+          error: `Product ${input.productId} not found or not owned by this team.`
+        };
+      }
+      items.push(
+        lineItemFromProduct(
+          product,
+          {
+            quantity: input.quantity,
+            customDescription: input.name,
+            customPrice: input.price
+          },
+          defaults
+        )
+      );
+      continue;
+    }
+    const quantity = input.quantity ?? 1;
+    const price = input.price ?? 0;
+    const { vat, tax } = lineFinancials(quantity, price, defaults);
+    items.push({
+      name: input.name?.trim() || "(no description)",
+      quantity,
+      unit: input.unit || void 0,
+      price,
+      vat,
+      tax
+    });
+  }
+  return { items };
+}
+var QUOTE_COLUMNS = {
+  id: schema_exports.quotations.id,
+  teamId: schema_exports.quotations.teamId,
+  quotationNumber: schema_exports.quotations.quotationNumber,
+  status: schema_exports.quotations.status,
+  customerId: schema_exports.quotations.customerId,
+  customerName: schema_exports.quotations.customerName,
+  amount: schema_exports.quotations.amount,
+  subtotal: schema_exports.quotations.subtotal,
+  vat: schema_exports.quotations.vat,
+  currency: schema_exports.quotations.currency,
+  validUntil: schema_exports.quotations.validUntil,
+  createdAt: schema_exports.quotations.createdAt,
+  lineItems: schema_exports.quotations.lineItems,
+  template: schema_exports.quotations.template
+};
+function formatQuote(q3) {
+  const items = Array.isArray(q3.lineItems) ? q3.lineItems : [];
+  return `**${q3.quotationNumber ?? "(draft, no number)"}** (${q3.status})
+ID: ${q3.id}
+Customer: ${q3.customerName ?? q3.customerId ?? "(none)"}
+Total: ${q3.amount ?? "?"} ${q3.currency ?? ""} (subtotal ${q3.subtotal ?? "?"}, VAT ${q3.vat ?? 0})
+Line items: ${items.length}
+${q3.validUntil ? `Valid until: ${new Date(q3.validUntil).toLocaleDateString()}
+` : ""}Created: ${new Date(q3.createdAt).toLocaleDateString()}
+`;
+}
+function tiptapNote(text3) {
+  return {
+    type: "doc",
+    content: [{ type: "paragraph", content: [{ type: "text", text: text3 }] }]
+  };
+}
+async function handleGetQuotes(input) {
+  const { customerId, status, q: q3, pageSize = 20 } = input;
+  if (status && !QUOTE_STATUSES.includes(status)) {
+    return textResponse4(
+      `Error: invalid status "${status}". Allowed: ${QUOTE_STATUSES.join(", ")}.`
+    );
+  }
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  if (scope.teamIds.length === 0) {
+    return textResponse4("No accessible teams found.");
+  }
+  const filters = [inArray(schema_exports.quotations.teamId, scope.teamIds)];
+  if (customerId) filters.push(eq(schema_exports.quotations.customerId, customerId));
+  if (status) filters.push(eq(schema_exports.quotations.status, status));
+  if (q3) {
+    filters.push(
+      or(
+        ilike(schema_exports.quotations.quotationNumber, `%${q3}%`),
+        ilike(schema_exports.quotations.customerName, `%${q3}%`)
+      )
+    );
+  }
+  const rows = await db.select(QUOTE_COLUMNS).from(schema_exports.quotations).where(and(...filters)).orderBy(desc(schema_exports.quotations.createdAt)).limit(Math.min(pageSize, 100));
+  if (rows.length === 0) {
+    return textResponse4("No quotes found.");
+  }
+  const note = input.projectId ? "\nNote: `projectId` was ignored \u2014 quotations are not linked to projects." : "";
+  return textResponse4(
+    `Found ${rows.length} quote(s):
+
+${rows.map(formatQuote).join("\n")}${note}`
+  );
+}
+async function handleCreateQuote(input) {
+  const { customerId } = input;
+  if (!customerId) return textResponse4("Error: `customerId` is required.");
+  const status = input.status ?? "draft";
+  if (!SAFE_DRAFT_STATUSES.has(status)) {
+    return textResponse4(
+      `Error: this tool only creates draft quotes. Requested status "${status}" is not allowed. Sending/accepting a quote is a manual dashboard action.`
+    );
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [customer] = await db.select({
+    id: schema_exports.customers.id,
+    name: schema_exports.customers.name,
+    addressLine1: schema_exports.customers.addressLine1,
+    city: schema_exports.customers.city,
+    zip: schema_exports.customers.zip,
+    country: schema_exports.customers.country,
+    vatNumber: schema_exports.customers.vatNumber
+  }).from(schema_exports.customers).where(
+    and(
+      eq(schema_exports.customers.id, customerId),
+      inArray(schema_exports.customers.teamId, accessibleTeamIds)
+    )
+  ).limit(1);
+  if (!customer) {
+    return textResponse4(
+      `Customer ${customerId} not found or not owned by this team.`
+    );
+  }
+  const defaults = await loadTemplateDefaults(teamId);
+  const { items, error: error49 } = await resolveLineItems(
+    input.lineItems ?? [],
+    defaults,
+    teamId
+  );
+  if (error49) return textResponse4(`Error: ${error49}`);
+  const totals = computeTotals(items, defaults);
+  const quotationNumber = await nextQuotationNumber(teamId);
+  const template = buildQuoteTemplate(defaults, input.title);
+  const customerDetails = {
+    type: "doc",
+    content: [
+      { type: "paragraph", content: [{ type: "text", text: customer.name }] },
+      ...customer.addressLine1 ? [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: customer.addressLine1 }]
+        }
+      ] : [],
+      ...customer.zip || customer.city ? [
+        {
+          type: "paragraph",
+          content: [
+            {
+              type: "text",
+              text: [customer.zip, customer.city].filter(Boolean).join(" ")
+            }
+          ]
+        }
+      ] : [],
+      ...customer.country ? [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: customer.country }]
+        }
+      ] : [],
+      ...customer.vatNumber ? [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: `BTW: ${customer.vatNumber}` }]
+        }
+      ] : []
+    ]
+  };
+  const [created] = await db.insert(schema_exports.quotations).values({
+    teamId,
+    userId: null,
+    status: "draft",
+    quotationNumber,
+    customerId: customer.id,
+    customerName: customer.name,
+    currency: defaults.currency.toUpperCase(),
+    template,
+    customerDetails,
+    fromDetails: defaults.fromDetails ?? null,
+    paymentDetails: defaults.paymentDetails ?? null,
+    noteDetails: input.description ? tiptapNote(input.description) : null,
+    issueDate: (/* @__PURE__ */ new Date()).toISOString(),
+    validUntil: input.validUntil ?? null,
+    lineItems: items,
+    subtotal: totals.subtotal,
+    vat: totals.vat,
+    tax: totals.tax,
+    amount: totals.amount
+  }).returning(QUOTE_COLUMNS);
+  if (!created) return textResponse4("Failed to create quote.");
+  return textResponse4(
+    `\u2705 **Draft quote created**
+
+${formatQuote(created)}
+Status is \`draft\`. Review, then send/accept manually from the dashboard.`
+  );
+}
+async function loadQuoteInTeam(id, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [row] = await db.select(QUOTE_COLUMNS).from(schema_exports.quotations).where(
+    and(
+      eq(schema_exports.quotations.id, id),
+      inArray(schema_exports.quotations.teamId, accessibleTeamIds)
+    )
+  ).limit(1);
+  return row ?? null;
+}
+function notDraftResponse(quote) {
+  return textResponse4(
+    `Quote ${quote.quotationNumber ?? quote.id} has status "${quote.status}", not "draft". These tools only modify draft quotes \u2014 sent/accepted/rejected/expired quotes are immutable here so their product snapshots stay reproducible.`
+  );
+}
+async function handleUpdateQuote(input) {
+  const { id } = input;
+  if (!id) return textResponse4("Error: `id` is required.");
+  if (input.status !== void 0 && !SAFE_DRAFT_STATUSES.has(input.status)) {
+    return textResponse4(
+      `Error: status can only stay within {${[...SAFE_DRAFT_STATUSES].join(", ")}}. "${input.status}" (send/accept/reject/expire) must be done manually from the dashboard.`
+    );
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const quote = await loadQuoteInTeam(id, resolved.teamId);
+  if (!quote) {
+    return textResponse4(`Quote ${id} not found or not owned by this team.`);
+  }
+  if (quote.status !== "draft") return notDraftResponse(quote);
+  const defaults = templateDefaultsFromStored(quote.template, quote.currency);
+  const updates = {};
+  if (input.title !== void 0) {
+    updates.template = buildQuoteTemplate(defaults, input.title);
+  }
+  if (input.description !== void 0) {
+    updates.noteDetails = input.description ? tiptapNote(input.description) : null;
+  }
+  if (input.validUntil !== void 0) {
+    updates.validUntil = input.validUntil;
+  }
+  if (input.lineItems !== void 0) {
+    const { items, error: error49 } = await resolveLineItems(
+      input.lineItems,
+      defaults,
+      quote.teamId
+    );
+    if (error49) return textResponse4(`Error: ${error49}`);
+    const totals = computeTotals(items, defaults);
+    updates.lineItems = items;
+    updates.subtotal = totals.subtotal;
+    updates.vat = totals.vat;
+    updates.tax = totals.tax;
+    updates.amount = totals.amount;
+  }
+  if (Object.keys(updates).length === 0) {
+    return textResponse4(
+      "No fields to update. Provide at least one of: title, description, validUntil, lineItems."
+    );
+  }
+  updates.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const [updated] = await db.update(schema_exports.quotations).set(updates).where(eq(schema_exports.quotations.id, quote.id)).returning(QUOTE_COLUMNS);
+  if (!updated) return textResponse4(`Failed to update quote ${id}.`);
+  return textResponse4(`\u2705 **Draft quote updated**
+
+${formatQuote(updated)}`);
+}
+async function handleAddProductToQuote(input) {
+  const { quoteId, productId } = input;
+  if (!quoteId) return textResponse4("Error: `quoteId` is required.");
+  if (!productId) return textResponse4("Error: `productId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const quote = await loadQuoteInTeam(quoteId, resolved.teamId);
+  if (!quote) {
+    return textResponse4(`Quote ${quoteId} not found or not owned by this team.`);
+  }
+  if (quote.status !== "draft") return notDraftResponse(quote);
+  const products = await loadProductsInTeam([productId], quote.teamId);
+  const product = products.get(productId);
+  if (!product) {
+    return textResponse4(
+      `Product ${productId} not found or not owned by this team.`
+    );
+  }
+  const defaults = templateDefaultsFromStored(quote.template, quote.currency);
+  const newItem = lineItemFromProduct(
+    product,
+    {
+      quantity: input.quantity,
+      customDescription: input.customDescription,
+      customPrice: input.customPrice
+    },
+    defaults
+  );
+  const existing = Array.isArray(quote.lineItems) ? quote.lineItems : [];
+  const items = [...existing, newItem];
+  const totals = computeTotals(items, defaults);
+  const [updated] = await db.update(schema_exports.quotations).set({
+    lineItems: items,
+    subtotal: totals.subtotal,
+    vat: totals.vat,
+    tax: totals.tax,
+    amount: totals.amount,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq(schema_exports.quotations.id, quote.id)).returning(QUOTE_COLUMNS);
+  if (!updated) {
+    return textResponse4(`Failed to add product to quote ${quoteId}.`);
+  }
+  await db.update(schema_exports.invoiceProducts).set({
+    usageCount: sql`${schema_exports.invoiceProducts.usageCount} + 1`,
+    lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq(schema_exports.invoiceProducts.id, product.id));
+  const snap = newItem.productSnapshot;
+  return textResponse4(
+    `\u2705 **Product added to draft quote ${updated.quotationNumber ?? updated.id}**
+
+Line item: ${newItem.name} \xD7 ${newItem.quantity}${newItem.unit ? ` ${newItem.unit}` : ""} @ ${newItem.price} ${snap.currency}
+Snapshot: name="${snap.name}", unitPrice=${snap.unitPrice}, currency=${snap.currency}, vatRate=${snap.vatRate}%, unit=${snap.unit ?? "-"}
+
+New quote total: ${updated.amount} ${updated.currency} (subtotal ${updated.subtotal}, VAT ${updated.vat})
+The snapshot is immutable: later catalog edits won't change this quote.`
+  );
+}
+
 // src/tools/teams.ts
 async function handleGetTeams() {
   const ctx = getAuthContext();
@@ -118793,7 +120282,7 @@ var EXT_MIME = {
   ppt: "application/vnd.ms-powerpoint",
   pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
-function textResponse3(text3) {
+function textResponse5(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function mimeFromName(name21) {
@@ -118874,12 +120363,12 @@ async function handleUploadTicketAttachment(input) {
     (v2) => typeof v2 === "string" && v2.trim().length > 0
   );
   if (sources.length === 0) {
-    return textResponse3(
+    return textResponse5(
       "Provide exactly one source: filePath (absolute local path), imageUrl, or base64Data."
     );
   }
   if (sources.length > 1) {
-    return textResponse3(
+    return textResponse5(
       "Provide only one source (filePath, imageUrl, or base64Data), not several."
     );
   }
@@ -118899,7 +120388,7 @@ async function handleUploadTicketAttachment(input) {
     } else if (input.imageUrl) {
       const res = await fetch(input.imageUrl);
       if (!res.ok) {
-        return textResponse3(
+        return textResponse5(
           `Could not download from URL: HTTP ${res.status}.`
         );
       }
@@ -118927,22 +120416,22 @@ async function handleUploadTicketAttachment(input) {
       }
     }
   } catch (error49) {
-    return textResponse3(
+    return textResponse5(
       `Failed to read the file: ${error49 instanceof Error ? error49.message : String(error49)}`
     );
   }
   if (buffer2.byteLength === 0) {
-    return textResponse3("The file is empty (0 bytes); nothing to upload.");
+    return textResponse5("The file is empty (0 bytes); nothing to upload.");
   }
   if (buffer2.byteLength > MAX_FILE_SIZE) {
-    return textResponse3(
+    return textResponse5(
       `File too large (${(buffer2.byteLength / 1024 / 1024).toFixed(
         1
       )} MB). Max: 25 MB.`
     );
   }
   if (!ALLOWED_MIME_TYPES.has(mimeType)) {
-    return textResponse3(
+    return textResponse5(
       `Unsupported file type: ${mimeType}. Allowed: JPEG, PNG, GIF, WebP, PDF, DOC(X), XLS(X), PPT(X), TXT, CSV.`
     );
   }
@@ -118955,7 +120444,7 @@ async function handleUploadTicketAttachment(input) {
       options: { contentType: mimeType, upsert: true }
     });
   } catch (error49) {
-    return textResponse3(
+    return textResponse5(
       `Upload failed: ${error49 instanceof Error ? error49.message : String(error49)}`
     );
   }
@@ -118978,7 +120467,7 @@ async function handleUploadTicketAttachment(input) {
     url3 = signed.url;
   } catch {
   }
-  return textResponse3(
+  return textResponse5(
     `\u{1F4CE} **Attached to ${ticket.ticketNumber}**
 File: ${fileName}
 Type: ${mimeType}
@@ -119314,11 +120803,11 @@ async function handleCreateTag(input) {
   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 scopeFilter2 = 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,
+      scopeFilter2,
       sql`lower(${schema_exports.tags.name}) = ${normalized}`
     )
   ).limit(1);
@@ -119364,6 +120853,346 @@ ${created.projectId ? `Project ID: ${created.projectId}
   };
 }
 
+// src/tools/tag-merge-util.ts
+function planRelationMerge(sourceRows, targetEntityIds) {
+  const targetSet = new Set(targetEntityIds);
+  const teamByEntity = /* @__PURE__ */ new Map();
+  for (const row of sourceRows) {
+    if (!teamByEntity.has(row.entityId)) {
+      teamByEntity.set(row.entityId, row.teamId);
+    }
+  }
+  const toInsert = [];
+  let skippedDuplicates = 0;
+  for (const [entityId, teamId] of teamByEntity) {
+    if (targetSet.has(entityId)) {
+      skippedDuplicates += 1;
+    } else {
+      toInsert.push({ entityId, teamId });
+    }
+  }
+  return {
+    toInsert,
+    skippedDuplicates,
+    sourceEntityCount: teamByEntity.size
+  };
+}
+function isValidTagName(name21) {
+  return typeof name21 === "string" && name21.trim().length > 0;
+}
+function totalTagUsage(usage) {
+  return usage.tickets + usage.customers + usage.projects + usage.transactions;
+}
+function formatTagUsage(usage) {
+  const parts = [];
+  if (usage.tickets) parts.push(`${usage.tickets} ticket(s)`);
+  if (usage.customers) parts.push(`${usage.customers} customer(s)`);
+  if (usage.projects) parts.push(`${usage.projects} project(s)`);
+  if (usage.transactions) parts.push(`${usage.transactions} transaction(s)`);
+  return parts.length > 0 ? parts.join(", ") : "no entities";
+}
+
+// src/tools/tag-management.ts
+function textResponse6(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+var TAG_COLUMNS = {
+  id: schema_exports.tags.id,
+  name: schema_exports.tags.name,
+  teamId: schema_exports.tags.teamId,
+  projectId: schema_exports.tags.projectId,
+  createdAt: schema_exports.tags.createdAt
+};
+function describeTag(tag) {
+  return `**${tag.name}** (id: ${tag.id})${tag.projectId ? ` [project-specific: ${tag.projectId}]` : " [general]"}`;
+}
+async function loadTagInTeam(tagId, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [row] = await db.select(TAG_COLUMNS).from(schema_exports.tags).where(
+    and(
+      eq(schema_exports.tags.id, tagId),
+      inArray(schema_exports.tags.teamId, accessibleTeamIds)
+    )
+  ).limit(1);
+  return row ?? null;
+}
+async function getTagUsage(tagId) {
+  const [tickets3, customers2, projects2, transactions2] = await Promise.all([
+    db.select({ value: count() }).from(schema_exports.ticketTags).where(eq(schema_exports.ticketTags.tagId, tagId)),
+    db.select({ value: count() }).from(schema_exports.customerTags).where(eq(schema_exports.customerTags.tagId, tagId)),
+    db.select({ value: count() }).from(schema_exports.projectTags).where(eq(schema_exports.projectTags.tagId, tagId)),
+    db.select({ value: count() }).from(schema_exports.transactionTags).where(eq(schema_exports.transactionTags.tagId, tagId))
+  ]);
+  return {
+    tickets: Number(tickets3[0]?.value ?? 0),
+    customers: Number(customers2[0]?.value ?? 0),
+    projects: Number(projects2[0]?.value ?? 0),
+    transactions: Number(transactions2[0]?.value ?? 0)
+  };
+}
+function scopeFilter(projectId) {
+  return projectId === null ? isNull(schema_exports.tags.projectId) : eq(schema_exports.tags.projectId, projectId);
+}
+async function handleUpdateTag(input) {
+  if (!input.tagId) return textResponse6("Error: `tagId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const existing = await loadTagInTeam(input.tagId, resolved.teamId);
+  if (!existing) {
+    return textResponse6(
+      `Tag ${input.tagId} not found, or it is not owned by this team.`
+    );
+  }
+  const renaming = input.name !== void 0;
+  const rescoping = input.projectId !== void 0;
+  if (!renaming && !rescoping) {
+    return textResponse6(
+      "No changes requested. Provide `name` to rename and/or `projectId` (string, or null for a general tag) to change scope."
+    );
+  }
+  if (renaming && !isValidTagName(input.name)) {
+    return textResponse6("Error: `name` cannot be empty.");
+  }
+  const nextName = renaming ? input.name.trim() : existing.name;
+  const nextProjectId = rescoping ? input.projectId ?? null : existing.projectId;
+  const [collision] = await db.select({ id: schema_exports.tags.id, name: schema_exports.tags.name }).from(schema_exports.tags).where(
+    and(
+      eq(schema_exports.tags.teamId, existing.teamId),
+      scopeFilter(nextProjectId),
+      sql`lower(${schema_exports.tags.name}) = ${normalizeTagName(nextName)}`,
+      ne(schema_exports.tags.id, existing.id)
+    )
+  ).limit(1);
+  if (collision) {
+    return textResponse6(
+      `\u274C Cannot update: another tag already uses the name "${collision.name}" (id: ${collision.id}) in this scope. Use merge-tags to combine them instead of renaming.`
+    );
+  }
+  const [updated] = await db.update(schema_exports.tags).set({ name: nextName, projectId: nextProjectId }).where(eq(schema_exports.tags.id, existing.id)).returning(TAG_COLUMNS);
+  if (!updated) return textResponse6(`Failed to update tag ${input.tagId}.`);
+  return textResponse6(
+    `\u2705 **Tag updated**
+
+${describeTag(updated)}
+
+Existing ticket/customer/project/transaction tag relations are preserved.`
+  );
+}
+async function handleDeleteTag(input) {
+  if (!input.tagId) return textResponse6("Error: `tagId` is required.");
+  const mode = input.mode ?? "delete_if_unused";
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const existing = await loadTagInTeam(input.tagId, resolved.teamId);
+  if (!existing) {
+    return textResponse6(
+      `Tag ${input.tagId} not found, or it is not owned by this team.`
+    );
+  }
+  const usage = await getTagUsage(existing.id);
+  const total = totalTagUsage(usage);
+  if (mode === "archive") {
+    return textResponse6(
+      `\u2139\uFE0F Archiving is not supported for team tags: the \`tags\` table has no archived column. ${describeTag(existing)} is used by ${formatTagUsage(usage)}.
+
+Options: use merge-tags to fold it into another tag, or delete it once it is unused (mode: delete_if_unused).`
+    );
+  }
+  if (total > 0) {
+    return textResponse6(
+      `\u274C Refusing to delete ${describeTag(existing)}: it is still used by ${formatTagUsage(usage)}. Deleting would strip the tag off those entities.
+
+Use merge-tags to move usage onto another tag first, then delete the (now-empty) tag.`
+    );
+  }
+  await db.delete(schema_exports.tags).where(eq(schema_exports.tags.id, existing.id));
+  return textResponse6(
+    `\u2705 **Tag deleted** (was unused): ${describeTag(existing)}`
+  );
+}
+async function resolveMergeTarget(teamId, input) {
+  if (input.targetTagId) {
+    const tag = await loadTagInTeam(input.targetTagId, teamId);
+    if (!tag) {
+      return {
+        ok: false,
+        response: textResponse6(
+          `Target tag ${input.targetTagId} not found, or it is not owned by this team.`
+        )
+      };
+    }
+    return { ok: true, tag, created: false };
+  }
+  if (!isValidTagName(input.targetName)) {
+    return {
+      ok: false,
+      response: textResponse6(
+        "Error: provide either `targetTagId` or a non-empty `targetName`."
+      )
+    };
+  }
+  const normalized = normalizeTagName(input.targetName);
+  const matches = await db.select(TAG_COLUMNS).from(schema_exports.tags).where(
+    and(
+      eq(schema_exports.tags.teamId, teamId),
+      sql`lower(${schema_exports.tags.name}) = ${normalized}`
+    )
+  );
+  if (matches.length > 0) {
+    const general = matches.find((t8) => t8.projectId === null);
+    return { ok: true, tag: general ?? matches[0], created: false };
+  }
+  const [created] = await db.insert(schema_exports.tags).values({ teamId, name: input.targetName.trim(), projectId: null }).returning(TAG_COLUMNS);
+  if (!created) {
+    return { ok: false, response: textResponse6("Failed to create target tag.") };
+  }
+  return { ok: true, tag: created, created: true };
+}
+async function handleMergeTags(input) {
+  const rawSourceIds = [...new Set(input.sourceTagIds ?? [])].filter(Boolean);
+  if (rawSourceIds.length === 0) {
+    return textResponse6("Error: `sourceTagIds` must contain at least one tag id.");
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const accessibleTeamIds = await getAccessibleTeamIds(resolved.teamId);
+  const sourceTags = await db.select(TAG_COLUMNS).from(schema_exports.tags).where(
+    and(
+      inArray(schema_exports.tags.id, rawSourceIds),
+      inArray(schema_exports.tags.teamId, accessibleTeamIds)
+    )
+  );
+  const foundIds = new Set(sourceTags.map((t8) => t8.id));
+  const missing = rawSourceIds.filter((id) => !foundIds.has(id));
+  if (missing.length > 0) {
+    return textResponse6(
+      `Error: source tag(s) not found or not owned by this team: ${missing.join(", ")}.`
+    );
+  }
+  const target = await resolveMergeTarget(resolved.teamId, input);
+  if (!target.ok) return target.response;
+  const sourcesToMerge = sourceTags.filter((t8) => t8.id !== target.tag.id);
+  if (sourcesToMerge.length === 0) {
+    return textResponse6(
+      "Error: nothing to merge \u2014 the only source tag is the same as the target tag."
+    );
+  }
+  const sourceIds = sourcesToMerge.map((t8) => t8.id);
+  const targetId = target.tag.id;
+  const deleteSources = input.deleteSources ?? true;
+  const results = await db.transaction(async (tx) => {
+    const ticketSrc = await tx.select({
+      entityId: schema_exports.ticketTags.ticketId,
+      teamId: schema_exports.ticketTags.teamId
+    }).from(schema_exports.ticketTags).where(inArray(schema_exports.ticketTags.tagId, sourceIds));
+    const ticketTgt = await tx.select({ entityId: schema_exports.ticketTags.ticketId }).from(schema_exports.ticketTags).where(eq(schema_exports.ticketTags.tagId, targetId));
+    const ticketPlan = planRelationMerge(
+      ticketSrc,
+      ticketTgt.map((r6) => r6.entityId)
+    );
+    if (ticketPlan.toInsert.length > 0) {
+      await tx.insert(schema_exports.ticketTags).values(
+        ticketPlan.toInsert.map((r6) => ({
+          ticketId: r6.entityId,
+          tagId: targetId,
+          teamId: r6.teamId
+        }))
+      );
+    }
+    await tx.delete(schema_exports.ticketTags).where(inArray(schema_exports.ticketTags.tagId, sourceIds));
+    const customerSrc = await tx.select({
+      entityId: schema_exports.customerTags.customerId,
+      teamId: schema_exports.customerTags.teamId
+    }).from(schema_exports.customerTags).where(inArray(schema_exports.customerTags.tagId, sourceIds));
+    const customerTgt = await tx.select({ entityId: schema_exports.customerTags.customerId }).from(schema_exports.customerTags).where(eq(schema_exports.customerTags.tagId, targetId));
+    const customerPlan = planRelationMerge(
+      customerSrc,
+      customerTgt.map((r6) => r6.entityId)
+    );
+    if (customerPlan.toInsert.length > 0) {
+      await tx.insert(schema_exports.customerTags).values(
+        customerPlan.toInsert.map((r6) => ({
+          customerId: r6.entityId,
+          tagId: targetId,
+          teamId: r6.teamId
+        }))
+      );
+    }
+    await tx.delete(schema_exports.customerTags).where(inArray(schema_exports.customerTags.tagId, sourceIds));
+    const projectSrc = await tx.select({
+      entityId: schema_exports.projectTags.projectId,
+      teamId: schema_exports.projectTags.teamId
+    }).from(schema_exports.projectTags).where(inArray(schema_exports.projectTags.tagId, sourceIds));
+    const projectTgt = await tx.select({ entityId: schema_exports.projectTags.projectId }).from(schema_exports.projectTags).where(eq(schema_exports.projectTags.tagId, targetId));
+    const projectPlan = planRelationMerge(
+      projectSrc,
+      projectTgt.map((r6) => r6.entityId)
+    );
+    if (projectPlan.toInsert.length > 0) {
+      await tx.insert(schema_exports.projectTags).values(
+        projectPlan.toInsert.map((r6) => ({
+          projectId: r6.entityId,
+          tagId: targetId,
+          teamId: r6.teamId
+        }))
+      );
+    }
+    await tx.delete(schema_exports.projectTags).where(inArray(schema_exports.projectTags.tagId, sourceIds));
+    const txnSrc = await tx.select({
+      entityId: schema_exports.transactionTags.transactionId,
+      teamId: schema_exports.transactionTags.teamId
+    }).from(schema_exports.transactionTags).where(inArray(schema_exports.transactionTags.tagId, sourceIds));
+    const txnTgt = await tx.select({ entityId: schema_exports.transactionTags.transactionId }).from(schema_exports.transactionTags).where(eq(schema_exports.transactionTags.tagId, targetId));
+    const txnPlan = planRelationMerge(
+      txnSrc,
+      txnTgt.map((r6) => r6.entityId)
+    );
+    if (txnPlan.toInsert.length > 0) {
+      await tx.insert(schema_exports.transactionTags).values(
+        txnPlan.toInsert.map((r6) => ({
+          transactionId: r6.entityId,
+          tagId: targetId,
+          teamId: r6.teamId
+        }))
+      );
+    }
+    await tx.delete(schema_exports.transactionTags).where(inArray(schema_exports.transactionTags.tagId, sourceIds));
+    if (deleteSources) {
+      await tx.delete(schema_exports.tags).where(inArray(schema_exports.tags.id, sourceIds));
+    }
+    return {
+      tickets: planToResult(ticketPlan),
+      customers: planToResult(customerPlan),
+      projects: planToResult(projectPlan),
+      transactions: planToResult(txnPlan)
+    };
+  });
+  const movedTotal = results.tickets.moved + results.customers.moved + results.projects.moved + results.transactions.moved;
+  const skippedTotal = results.tickets.skipped + results.customers.skipped + results.projects.skipped + results.transactions.skipped;
+  const line2 = (label, r6) => `- ${label}: ${r6.moved} moved, ${r6.skipped} skipped (duplicate)`;
+  return textResponse6(
+    `\u2705 **Tags merged** into ${describeTag(target.tag)}${target.created ? " (newly created)" : ""}
+
+Sources (${sourcesToMerge.length}): ${sourcesToMerge.map((t8) => `${t8.name} (${t8.id})`).join(", ")}
+
+Relations moved (duplicates skipped to keep a single tag per entity):
+${line2("Tickets", results.tickets)}
+${line2("Customers", results.customers)}
+${line2("Projects", results.projects)}
+${line2("Transactions", results.transactions)}
+
+Totals: ${movedTotal} relation(s) moved, ${skippedTotal} duplicate(s) skipped.
+Source tags ${deleteSources ? "deleted" : "kept (now empty)"}: ${sourcesToMerge.map((t8) => t8.id).join(", ")}.`
+  );
+}
+function planToResult(plan) {
+  return {
+    moved: plan.toInsert.length,
+    skipped: plan.skippedDuplicates,
+    total: plan.sourceEntityCount
+  };
+}
+
 // src/utils/ticket-number.ts
 async function isTicketNumberTaken(ticketDb, teamId, ticketNumber, excludeTicketId) {
   const conditions = [
@@ -119688,6 +121517,527 @@ ${changes.map((c6) => `   \u2022 ${c6}`).join("\n")}` : "No field changes were a
   };
 }
 
+// src/tools/trip-billing-util.ts
+var TRIP_BILLING_TYPES = [
+  "not_billable",
+  "per_km",
+  "per_trip"
+];
+var TRIP_LOCKED_FIELDS = [
+  "date",
+  "startLocation",
+  "endLocation",
+  "tripType",
+  "distance",
+  "odometerStart",
+  "odometerEnd",
+  "billingType",
+  "rate",
+  "amount",
+  "invoiceId",
+  "isInvoiced"
+];
+function round22(value) {
+  return Math.round(value * 100) / 100;
+}
+function deriveTripAmount(input) {
+  if (input.amount != null) return input.amount;
+  if (input.rate == null) return null;
+  if (input.billingType === "per_trip") return round22(input.rate);
+  if (input.billingType === "per_km" && input.distance != null) {
+    return round22(input.distance * input.rate);
+  }
+  return null;
+}
+function attemptedLockedFields(update) {
+  return TRIP_LOCKED_FIELDS.filter((field) => update[field] !== void 0);
+}
+
+// src/tools/trips.ts
+var TRIP_TYPES = ["private", "business"];
+var BILLING_TYPES = TRIP_BILLING_TYPES;
+function textResponse7(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+function jsonResponse(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+function toNumber2(value) {
+  if (value == null) return 0;
+  if (typeof value === "number") return value;
+  const parsed = Number.parseFloat(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function formatTrip(t8) {
+  return {
+    id: t8.id,
+    date: t8.date,
+    startLocation: t8.startLocation,
+    endLocation: t8.endLocation,
+    tripType: t8.tripType,
+    distance: t8.distance != null ? toNumber2(t8.distance) : null,
+    odometerStart: t8.odometerStart != null ? toNumber2(t8.odometerStart) : null,
+    odometerEnd: t8.odometerEnd != null ? toNumber2(t8.odometerEnd) : null,
+    billingType: t8.billingType,
+    rate: t8.rate,
+    amount: t8.amount,
+    isInvoiced: t8.isInvoiced,
+    invoiceId: t8.invoiceId,
+    notes: t8.notes,
+    user: t8.user ? { id: t8.user.id, name: t8.user.fullName } : null,
+    project: t8.project ? { id: t8.project.id, name: t8.project.name } : null,
+    customer: t8.customer ? { id: t8.customer.id, name: t8.customer.name } : null,
+    invoice: t8.invoice ? {
+      id: t8.invoice.id,
+      invoiceNumber: t8.invoice.invoiceNumber,
+      status: t8.invoice.status
+    } : null,
+    vehicle: t8.vehicle ? {
+      id: t8.vehicle.id,
+      name: t8.vehicle.name,
+      licensePlate: t8.vehicle.licensePlate
+    } : null,
+    snapshotId: t8.snapshotId,
+    linkedTripId: t8.linkedTripId
+  };
+}
+var TRIP_RELATIONS = {
+  user: { columns: { id: true, fullName: true } },
+  project: { columns: { id: true, name: true } },
+  customer: { columns: { id: true, name: true } },
+  invoice: { columns: { id: true, invoiceNumber: true, status: true } },
+  vehicle: { columns: { id: true, name: true, licensePlate: true } }
+};
+async function handleGetTrips(input) {
+  if (input.tripType && !TRIP_TYPES.includes(input.tripType)) {
+    return textResponse7(
+      `Error: invalid tripType "${input.tripType}". Allowed: ${TRIP_TYPES.join(", ")}.`
+    );
+  }
+  if (input.billingType && !BILLING_TYPES.includes(input.billingType)) {
+    return textResponse7(
+      `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES.join(", ")}.`
+    );
+  }
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  if (scope.teamIds.length === 0) {
+    return textResponse7("No accessible teams found.");
+  }
+  const filters = [inArray(schema_exports.trips.teamId, scope.teamIds)];
+  if (input.dateFrom) filters.push(gte(schema_exports.trips.date, input.dateFrom));
+  if (input.dateTo) filters.push(lte(schema_exports.trips.date, input.dateTo));
+  if (input.userId) filters.push(eq(schema_exports.trips.userId, input.userId));
+  if (input.projectId) {
+    filters.push(eq(schema_exports.trips.projectId, input.projectId));
+  }
+  if (input.customerId) {
+    filters.push(eq(schema_exports.trips.customerId, input.customerId));
+  }
+  if (input.tripType) {
+    filters.push(eq(schema_exports.trips.tripType, input.tripType));
+  }
+  if (input.billingType) {
+    filters.push(
+      eq(schema_exports.trips.billingType, input.billingType)
+    );
+  }
+  if (input.isInvoiced !== void 0) {
+    filters.push(eq(schema_exports.trips.isInvoiced, input.isInvoiced));
+  }
+  const pageSize = Math.min(input.pageSize ?? 50, 200);
+  const rows = await db.query.trips.findMany({
+    where: and(...filters),
+    with: TRIP_RELATIONS,
+    orderBy: [desc(schema_exports.trips.date), desc(schema_exports.trips.createdAt)],
+    limit: pageSize
+  });
+  const totals = rows.reduce(
+    (acc, t8) => {
+      const distance = toNumber2(t8.distance);
+      const amount = t8.amount ?? 0;
+      if (t8.tripType === "business") acc.businessKm += distance;
+      else acc.privateKm += distance;
+      acc.totalKm += distance;
+      acc.totalAmount += amount;
+      return acc;
+    },
+    { businessKm: 0, privateKm: 0, totalKm: 0, totalAmount: 0 }
+  );
+  return jsonResponse({
+    count: rows.length,
+    totals: {
+      businessKm: round22(totals.businessKm),
+      privateKm: round22(totals.privateKm),
+      totalKm: round22(totals.totalKm),
+      totalAmount: round22(totals.totalAmount)
+    },
+    trips: rows.map(formatTrip)
+  });
+}
+async function loadTripInTeams(id, teamIds) {
+  const row = await db.query.trips.findFirst({
+    where: and(
+      eq(schema_exports.trips.id, id),
+      inArray(schema_exports.trips.teamId, teamIds)
+    ),
+    with: TRIP_RELATIONS
+  });
+  return row ?? null;
+}
+async function validateLinks(ctxUserId, teamId, links) {
+  if (links.projectId) {
+    const projectIds = await getAccessibleProjectIds(ctxUserId, teamId);
+    if (!projectIds.includes(links.projectId)) {
+      return `Project not found or no access: ${links.projectId}. Call get-projects first.`;
+    }
+  }
+  if (links.customerId) {
+    const customerIds = await getAccessibleCustomerIds(teamId);
+    if (!customerIds.includes(links.customerId)) {
+      return `Customer not found or no access: ${links.customerId}. Call get-customers first.`;
+    }
+  }
+  if (links.vehicleId) {
+    const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+    const [vehicle] = await db.select({ id: schema_exports.vehicles.id }).from(schema_exports.vehicles).where(
+      and(
+        eq(schema_exports.vehicles.id, links.vehicleId),
+        inArray(schema_exports.vehicles.teamId, accessibleTeamIds)
+      )
+    ).limit(1);
+    if (!vehicle) {
+      return `Vehicle not found or no access: ${links.vehicleId}. Call get-vehicles first.`;
+    }
+  }
+  return null;
+}
+async function validateInvoice(invoiceId, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [invoice] = await db.select({ id: schema_exports.invoices.id }).from(schema_exports.invoices).where(
+    and(
+      eq(schema_exports.invoices.id, invoiceId),
+      inArray(schema_exports.invoices.teamId, accessibleTeamIds)
+    )
+  ).limit(1);
+  return invoice ? null : `Invoice not found or no access: ${invoiceId}. Call get-invoices first.`;
+}
+async function handleCreateTrip(input) {
+  const ctx = getAuthContext();
+  if (!input.date) return textResponse7("Error: `date` (YYYY-MM-DD) is required.");
+  if (!input.startLocation || !input.endLocation) {
+    return textResponse7(
+      "Error: `startLocation` and `endLocation` are required."
+    );
+  }
+  if (!input.tripType || !TRIP_TYPES.includes(input.tripType)) {
+    return textResponse7(
+      `Error: \`tripType\` is required and must be one of: ${TRIP_TYPES.join(", ")}.`
+    );
+  }
+  const billingType = input.billingType ?? "not_billable";
+  if (!BILLING_TYPES.includes(billingType)) {
+    return textResponse7(
+      `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES.join(", ")}.`
+    );
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const linkError = await validateLinks(ctx.userId, teamId, {
+    projectId: input.projectId,
+    customerId: input.customerId,
+    vehicleId: input.vehicleId
+  });
+  if (linkError) return textResponse7(`Error: ${linkError}`);
+  if (!input.allowDuplicate) {
+    const dupFilters = [
+      eq(schema_exports.trips.teamId, teamId),
+      eq(schema_exports.trips.userId, ctx.userId),
+      eq(schema_exports.trips.date, input.date),
+      ilike(schema_exports.trips.startLocation, input.startLocation),
+      ilike(schema_exports.trips.endLocation, input.endLocation)
+    ];
+    if (input.projectId) {
+      dupFilters.push(eq(schema_exports.trips.projectId, input.projectId));
+    }
+    if (input.customerId) {
+      dupFilters.push(eq(schema_exports.trips.customerId, input.customerId));
+    }
+    const [dup] = await db.select({ id: schema_exports.trips.id, distance: schema_exports.trips.distance }).from(schema_exports.trips).where(and(...dupFilters)).limit(1);
+    if (dup) {
+      return textResponse7(
+        `\u26A0\uFE0F A matching trip already exists for ${input.date} (${input.startLocation} \u2192 ${input.endLocation}): trip ${dup.id}${dup.distance != null ? ` (${toNumber2(dup.distance)} km)` : ""}. Not creating a duplicate. Use update-trip to adjust it, or re-call create-trip with allowDuplicate: true to record a second trip anyway.`
+      );
+    }
+  }
+  const amount = deriveTripAmount({
+    billingType,
+    distance: input.distance ?? null,
+    rate: input.rate ?? null,
+    amount: input.amount ?? null
+  });
+  const [created] = await db.insert(schema_exports.trips).values({
+    teamId,
+    userId: ctx.userId,
+    date: input.date,
+    startLocation: input.startLocation,
+    endLocation: input.endLocation,
+    tripType: input.tripType,
+    distance: input.distance != null ? String(input.distance) : null,
+    odometerStart: input.odometerStart != null ? String(input.odometerStart) : null,
+    odometerEnd: input.odometerEnd != null ? String(input.odometerEnd) : null,
+    projectId: input.projectId ?? null,
+    customerId: input.customerId ?? null,
+    billingType,
+    rate: input.rate ?? null,
+    amount,
+    notes: input.notes ?? null,
+    vehicleId: input.vehicleId ?? null,
+    snapshotId: input.snapshotId ?? null
+  }).returning({ id: schema_exports.trips.id });
+  if (!created) return textResponse7("Failed to create trip.");
+  const trip = await loadTripInTeams(created.id, [teamId]);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Trip created**
+
+${JSON.stringify(formatTrip(trip), null, 2)}`
+      }
+    ]
+  };
+}
+async function handleUpdateTrip(input) {
+  const ctx = getAuthContext();
+  if (!input.id) return textResponse7("Error: `id` is required.");
+  if (input.tripType && !TRIP_TYPES.includes(input.tripType)) {
+    return textResponse7(
+      `Error: invalid tripType "${input.tripType}". Allowed: ${TRIP_TYPES.join(", ")}.`
+    );
+  }
+  if (input.billingType && !BILLING_TYPES.includes(input.billingType)) {
+    return textResponse7(
+      `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES.join(", ")}.`
+    );
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const accessibleTeamIds = await getAccessibleTeamIds(resolved.teamId);
+  const existing = await loadTripInTeams(input.id, accessibleTeamIds);
+  if (!existing) {
+    return textResponse7(
+      `Trip ${input.id} not found or you don't have access to it. Call get-trips to find a valid id.`
+    );
+  }
+  const teamId = resolved.teamId;
+  const isLocked = existing.isInvoiced || existing.invoiceId != null;
+  if (isLocked && !input.allowInvoicedOverride) {
+    const attempted = attemptedLockedFields(
+      input
+    );
+    if (attempted.length > 0) {
+      return textResponse7(
+        `Error: trip ${input.id} is invoiced${existing.invoiceId ? ` (invoice ${existing.invoiceId})` : ""}. Financial/distance fields are locked: ${attempted.join(", ")}. Re-call with allowInvoicedOverride: true to change them anyway, or only update project/customer/notes/vehicle links.`
+      );
+    }
+  }
+  const linkError = await validateLinks(ctx.userId, teamId, {
+    projectId: input.projectId ?? void 0,
+    customerId: input.customerId ?? void 0,
+    vehicleId: input.vehicleId ?? void 0
+  });
+  if (linkError) return textResponse7(`Error: ${linkError}`);
+  if (input.invoiceId) {
+    const invoiceError = await validateInvoice(input.invoiceId, teamId);
+    if (invoiceError) return textResponse7(`Error: ${invoiceError}`);
+  }
+  const updates = {};
+  if (input.date !== void 0) updates.date = input.date;
+  if (input.startLocation !== void 0) {
+    updates.startLocation = input.startLocation;
+  }
+  if (input.endLocation !== void 0) updates.endLocation = input.endLocation;
+  if (input.tripType !== void 0) updates.tripType = input.tripType;
+  if (input.distance !== void 0) {
+    updates.distance = input.distance != null ? String(input.distance) : null;
+  }
+  if (input.odometerStart !== void 0) {
+    updates.odometerStart = input.odometerStart != null ? String(input.odometerStart) : null;
+  }
+  if (input.odometerEnd !== void 0) {
+    updates.odometerEnd = input.odometerEnd != null ? String(input.odometerEnd) : null;
+  }
+  if (input.projectId !== void 0) updates.projectId = input.projectId;
+  if (input.customerId !== void 0) updates.customerId = input.customerId;
+  if (input.vehicleId !== void 0) updates.vehicleId = input.vehicleId;
+  if (input.notes !== void 0) updates.notes = input.notes;
+  if (input.billingType !== void 0) updates.billingType = input.billingType;
+  if (input.rate !== void 0) updates.rate = input.rate;
+  if (input.amount !== void 0) updates.amount = input.amount;
+  if (input.linkedTripId !== void 0) {
+    updates.linkedTripId = input.linkedTripId;
+  }
+  if (input.invoiceId !== void 0) {
+    updates.invoiceId = input.invoiceId;
+    if (input.isInvoiced === void 0) {
+      updates.isInvoiced = input.invoiceId != null;
+    }
+  }
+  if (input.isInvoiced !== void 0) updates.isInvoiced = input.isInvoiced;
+  if (input.amount === void 0 && (input.distance !== void 0 || input.rate !== void 0 || input.billingType !== void 0)) {
+    const nextBilling = input.billingType ?? existing.billingType;
+    const nextDistance = input.distance !== void 0 ? input.distance : existing.distance != null ? toNumber2(existing.distance) : null;
+    const nextRate = input.rate !== void 0 ? input.rate : existing.rate;
+    const derived = deriveTripAmount({
+      billingType: nextBilling,
+      distance: nextDistance,
+      rate: nextRate,
+      amount: null
+    });
+    if (derived != null) updates.amount = derived;
+  }
+  if (Object.keys(updates).length === 0) {
+    return textResponse7(
+      "No fields to update. Provide at least one editable field."
+    );
+  }
+  updates.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await db.update(schema_exports.trips).set(updates).where(
+    and(
+      eq(schema_exports.trips.id, existing.id),
+      inArray(schema_exports.trips.teamId, accessibleTeamIds)
+    )
+  );
+  const updated = await loadTripInTeams(existing.id, accessibleTeamIds);
+  return {
+    content: [
+      {
+        type: "text",
+        text: `\u2705 **Trip updated**
+
+${JSON.stringify(formatTrip(updated), null, 2)}`
+      }
+    ]
+  };
+}
+async function handleGetVehicles(input) {
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  if (scope.teamIds.length === 0) {
+    return textResponse7("No accessible teams found.");
+  }
+  const filters = [inArray(schema_exports.vehicles.teamId, scope.teamIds)];
+  if (input.q) filters.push(ilike(schema_exports.vehicles.name, `%${input.q}%`));
+  const rows = await db.select({
+    id: schema_exports.vehicles.id,
+    name: schema_exports.vehicles.name,
+    licensePlate: schema_exports.vehicles.licensePlate,
+    currentOdometer: schema_exports.vehicles.currentOdometer,
+    teamId: schema_exports.vehicles.teamId
+  }).from(schema_exports.vehicles).where(and(...filters)).orderBy(asc(schema_exports.vehicles.name)).limit(Math.min(input.pageSize ?? 50, 200));
+  return jsonResponse({
+    count: rows.length,
+    vehicles: rows.map((v2) => ({
+      id: v2.id,
+      name: v2.name,
+      licensePlate: v2.licensePlate,
+      currentOdometer: v2.currentOdometer != null ? toNumber2(v2.currentOdometer) : null
+    }))
+  });
+}
+async function handleGetTripTemplates(input) {
+  const ctx = getAuthContext();
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  if (scope.teamIds.length === 0) {
+    return textResponse7("No accessible teams found.");
+  }
+  const filters = [inArray(schema_exports.tripTemplates.teamId, scope.teamIds)];
+  const userId = input.userId ?? ctx.userId;
+  if (userId !== "all") {
+    filters.push(eq(schema_exports.tripTemplates.userId, userId));
+  }
+  const rows = await db.select({
+    id: schema_exports.tripTemplates.id,
+    name: schema_exports.tripTemplates.name,
+    startLocation: schema_exports.tripTemplates.startLocation,
+    endLocation: schema_exports.tripTemplates.endLocation,
+    distance: schema_exports.tripTemplates.distance,
+    withReturn: schema_exports.tripTemplates.withReturn,
+    returnDistance: schema_exports.tripTemplates.returnDistance,
+    tripType: schema_exports.tripTemplates.tripType,
+    billingType: schema_exports.tripTemplates.billingType,
+    rate: schema_exports.tripTemplates.rate,
+    amount: schema_exports.tripTemplates.amount,
+    projectId: schema_exports.tripTemplates.projectId,
+    customerId: schema_exports.tripTemplates.customerId,
+    vehicleId: schema_exports.tripTemplates.vehicleId,
+    notes: schema_exports.tripTemplates.notes
+  }).from(schema_exports.tripTemplates).where(and(...filters)).orderBy(asc(schema_exports.tripTemplates.name)).limit(Math.min(input.pageSize ?? 50, 200));
+  return jsonResponse({
+    count: rows.length,
+    templates: rows.map((t8) => ({
+      ...t8,
+      distance: t8.distance != null ? toNumber2(t8.distance) : null,
+      returnDistance: t8.returnDistance != null ? toNumber2(t8.returnDistance) : null
+    }))
+  });
+}
+async function handleGetFrequentTripsForProject(input) {
+  const ctx = getAuthContext();
+  if (!input.projectId) {
+    return textResponse7("Error: `projectId` is required.");
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const teamId = resolved.teamId;
+  const projectIds = await getAccessibleProjectIds(ctx.userId, teamId);
+  if (!projectIds.includes(input.projectId)) {
+    return textResponse7(
+      `Project not found or no access: ${input.projectId}. Call get-projects first.`
+    );
+  }
+  const userId = input.userId ?? ctx.userId;
+  const daysBack = input.daysBack ?? 60;
+  const limitN = Math.min(input.limit ?? 5, 25);
+  const fromDate = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1e3).toISOString().slice(0, 10);
+  const groups = await db.select({
+    startLocation: schema_exports.trips.startLocation,
+    endLocation: schema_exports.trips.endLocation,
+    tripType: schema_exports.trips.tripType,
+    count: sql`count(*)::int`,
+    avgDistance: sql`avg(${schema_exports.trips.distance})::text`,
+    lastUsedDate: sql`max(${schema_exports.trips.date})`
+  }).from(schema_exports.trips).where(
+    and(
+      eq(schema_exports.trips.teamId, teamId),
+      eq(schema_exports.trips.userId, userId),
+      eq(schema_exports.trips.projectId, input.projectId),
+      gte(schema_exports.trips.date, fromDate)
+    )
+  ).groupBy(
+    schema_exports.trips.startLocation,
+    schema_exports.trips.endLocation,
+    schema_exports.trips.tripType
+  ).orderBy(desc(sql`count(*)`), desc(sql`max(${schema_exports.trips.date})`)).limit(limitN);
+  return jsonResponse({
+    count: groups.length,
+    daysBack,
+    frequentTrips: groups.map((g6) => ({
+      startLocation: g6.startLocation,
+      endLocation: g6.endLocation,
+      tripType: g6.tripType,
+      count: g6.count,
+      avgDistance: g6.avgDistance != null ? round22(toNumber2(g6.avgDistance)) : null,
+      lastUsedDate: g6.lastUsedDate
+    }))
+  });
+}
+
 // src/tools/tickets.ts
 function isImageFile(mimeType) {
   return mimeType.startsWith("image/") && ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"].includes(
@@ -120170,6 +122520,12 @@ function createMcpServer() {
           return await handleGetTags(asToolArgs(toolArgs));
         case "create-tag":
           return await handleCreateTag(asToolArgs(toolArgs));
+        case "update-tag":
+          return await handleUpdateTag(asToolArgs(toolArgs));
+        case "delete-tag":
+          return await handleDeleteTag(asToolArgs(toolArgs));
+        case "merge-tags":
+          return await handleMergeTags(asToolArgs(toolArgs));
         case "get-calendar-items":
           return await handleGetCalendarItems(
             asToolArgs(toolArgs)
@@ -120202,12 +122558,32 @@ function createMcpServer() {
           return await handleGetCustomers(asToolArgs(toolArgs));
         case "create-customer":
           return await handleCreateCustomer(asToolArgs(toolArgs));
+        case "update-customer":
+          return await handleUpdateCustomer(
+            asToolArgs(toolArgs)
+          );
+        case "archive-customer":
+          return await handleArchiveCustomer(
+            asToolArgs(toolArgs)
+          );
+        case "delete-customer":
+          return await handleDeleteCustomer(
+            asToolArgs(toolArgs)
+          );
         case "get-projects":
           return await handleGetProjects(asToolArgs(toolArgs));
         case "create-project":
           return await handleCreateProject(asToolArgs(toolArgs));
         case "update-project":
           return await handleUpdateProject(asToolArgs(toolArgs));
+        case "archive-project":
+          return await handleArchiveProject(
+            asToolArgs(toolArgs)
+          );
+        case "delete-project":
+          return await handleDeleteProject(
+            asToolArgs(toolArgs)
+          );
         case "get-project-members":
           return await handleGetProjectMembers(
             asToolArgs(toolArgs)
@@ -120264,6 +122640,32 @@ function createMcpServer() {
           return await handleArchiveProduct(
             asToolArgs(toolArgs)
           );
+        case "get-trips":
+          return await handleGetTrips(asToolArgs(toolArgs));
+        case "create-trip":
+          return await handleCreateTrip(asToolArgs(toolArgs));
+        case "update-trip":
+          return await handleUpdateTrip(asToolArgs(toolArgs));
+        case "get-vehicles":
+          return await handleGetVehicles(asToolArgs(toolArgs));
+        case "get-trip-templates":
+          return await handleGetTripTemplates(
+            asToolArgs(toolArgs)
+          );
+        case "get-frequent-trips-for-project":
+          return await handleGetFrequentTripsForProject(
+            asToolArgs(toolArgs)
+          );
+        case "get-quotes":
+          return await handleGetQuotes(asToolArgs(toolArgs));
+        case "create-quote":
+          return await handleCreateQuote(asToolArgs(toolArgs));
+        case "update-quote":
+          return await handleUpdateQuote(asToolArgs(toolArgs));
+        case "add-product-to-quote":
+          return await handleAddProductToQuote(
+            asToolArgs(toolArgs)
+          );
         case "log-hours":
           return await handleLogHours(asToolArgs(toolArgs));
         case "get-github-file":