@mgsoftwarebv/mcp-server-bridge 3.4.0 → 3.5.0

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.",
@@ -105935,13 +106004,19 @@ var TOOLS = [
   },
   {
     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 +106043,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 +106070,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.",
@@ -106277,6 +106384,106 @@ var TOOLS = [
       required: ["documentId", "invoiceId"]
     }
   },
+  {
+    name: "get-products",
+    description: "List catalog products used on invoices AND quotes (the shared `invoice_products` catalog). Each entry includes its ID (UUID), name, unit price, currency, unit, active/archived flag, configurable flag, and usage stats. Editing or archiving a catalog product never changes existing invoices/quotes \u2014 those keep an immutable line-item snapshot; catalog changes only affect documents created afterwards.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        q: {
+          type: "string",
+          description: "Search query for product name/description"
+        },
+        status: {
+          type: "string",
+          enum: ["active", "archived", "all"],
+          default: "active",
+          description: "Filter by catalog status (archived = isActive false)"
+        },
+        currency: {
+          type: "string",
+          description: "Filter by currency code (e.g. EUR)"
+        },
+        pageSize: { type: "number", default: 20, maximum: 100 }
+      },
+      required: []
+    }
+  },
+  {
+    name: "get-product-by-id",
+    description: "Get a single catalog product by its ID (UUID), including name, unit price, currency, unit, active/archived flag, configurable flag, and usage stats.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        productId: { type: "string", description: "Product ID (UUID)" }
+      },
+      required: ["productId"]
+    }
+  },
+  {
+    name: "create-product",
+    description: "Create a catalog product for use on invoices and quotes. Stored in the shared `invoice_products` catalog. This only adds a reusable catalog entry; it does not place the product on any document. Returns the created product with its ID and normalized fields.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        name: { type: "string", description: "Product name" },
+        description: { type: "string" },
+        price: {
+          type: "number",
+          description: "Unit price (catalog default, excl. quantity)"
+        },
+        currency: { type: "string", description: "Currency code (e.g. EUR)" },
+        unit: {
+          type: "string",
+          description: "Unit label (e.g. hour, piece, month)"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "update-product",
+    description: "Update a catalog product's editable fields (name, description, price, currency, unit) or reactivate it (isActive: true). Only provided fields change. IMPORTANT: updates apply only to FUTURE invoices/quotes. Existing/sent/accepted/paid documents keep their immutable line-item snapshot and are never mutated. Find the product id via get-products.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        productId: { type: "string", description: "Product ID (UUID)" },
+        name: { type: "string" },
+        description: { type: ["string", "null"] },
+        price: {
+          type: ["number", "null"],
+          description: "Unit price (catalog default)"
+        },
+        currency: { type: ["string", "null"] },
+        unit: { type: ["string", "null"] },
+        isActive: {
+          type: "boolean",
+          description: "Set true to reactivate an archived product"
+        }
+      },
+      required: ["productId"]
+    }
+  },
+  {
+    name: "archive-product",
+    description: "Archive (soft-disable) a catalog product so it no longer appears in invoice/quote product pickers. Preferred over deletion: products referenced historically stay safe because invoices/quotes hold their own line-item snapshots. Reactivate later via update-product (isActive: true).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        productId: { type: "string", description: "Product ID (UUID)" },
+        reason: {
+          type: "string",
+          description: "Optional note about why it was archived (not persisted)"
+        }
+      },
+      required: ["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).",
@@ -107885,7 +108092,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}.`
     );
@@ -112465,10 +112672,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_LABELS = {
+  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_LABELS).filter((key) => counts[key] > 0).map((key) => `${counts[key]} ${DEPENDENCY_LABELS[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);
@@ -112485,25 +112741,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."}`
       }
     ]
   };
@@ -113004,6 +113268,305 @@ async function handleRemoveProjectMember(input) {
   }
   return textResponse(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 textResponse("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 textResponse(
+      `Project ${projectId} not found, or it is not owned by this team.`
+    );
+  }
+  const state2 = getProjectArchiveState(project.settings);
+  if (state2.archived) {
+    return textResponse(
+      `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 textResponse(
+    `\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 textResponse("Error: `projectId` is required.");
+  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 project = await loadProjectForCleanup(projectId, resolved.teamId);
+  if (!project) {
+    return textResponse(
+      `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 textResponse(
+      `\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 textResponse(
+      `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 textResponse(
+    `\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
+var PRODUCT_STATUSES = ["active", "archived", "all"];
+var PRODUCT_COLUMNS = {
+  id: schema_exports.invoiceProducts.id,
+  teamId: schema_exports.invoiceProducts.teamId,
+  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,
+  isActive: schema_exports.invoiceProducts.isActive,
+  usageCount: schema_exports.invoiceProducts.usageCount,
+  lastUsedAt: schema_exports.invoiceProducts.lastUsedAt,
+  createdAt: schema_exports.invoiceProducts.createdAt,
+  updatedAt: schema_exports.invoiceProducts.updatedAt
+};
+function textResponse2(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+function formatPrice(p3) {
+  if (p3.price == null) return "(no price)";
+  return `${p3.price}${p3.currency ? ` ${p3.currency}` : ""}${p3.unit ? ` / ${p3.unit}` : ""}`;
+}
+function formatProduct(p3) {
+  const flags = [p3.isActive ? "active" : "archived"];
+  if (p3.isConfigurable) flags.push("configurable");
+  return `**${p3.name}** (${flags.join(", ")})
+ID: ${p3.id}
+Price: ${formatPrice(p3)}
+${p3.description ? `Description: ${p3.description}
+` : ""}Used: ${p3.usageCount}x${p3.lastUsedAt ? ` (last ${new Date(p3.lastUsedAt).toLocaleDateString()})` : ""}
+`;
+}
+async function handleGetProducts(input) {
+  const { q: q3, currency, pageSize = 20 } = input;
+  const status = input.status ?? "active";
+  if (!PRODUCT_STATUSES.includes(status)) {
+    return textResponse2(
+      `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.");
+  }
+  const filters = [inArray(schema_exports.invoiceProducts.teamId, scope.teamIds)];
+  if (status === "active") {
+    filters.push(eq(schema_exports.invoiceProducts.isActive, true));
+  } else if (status === "archived") {
+    filters.push(eq(schema_exports.invoiceProducts.isActive, false));
+  }
+  if (currency) filters.push(eq(schema_exports.invoiceProducts.currency, currency));
+  if (q3) {
+    filters.push(
+      or(
+        sql`${schema_exports.invoiceProducts.fts} @@ plainto_tsquery('english', ${q3})`,
+        ilike(schema_exports.invoiceProducts.name, `%${q3}%`)
+      )
+    );
+  }
+  const rows = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(and(...filters)).orderBy(
+    desc(schema_exports.invoiceProducts.usageCount),
+    desc(schema_exports.invoiceProducts.lastUsedAt),
+    asc(schema_exports.invoiceProducts.name)
+  ).limit(Math.min(pageSize, 100));
+  if (rows.length === 0) {
+    return textResponse2(
+      `No products found${status !== "all" ? ` (status: ${status})` : ""}.`
+    );
+  }
+  return textResponse2(
+    `Found ${rows.length} product(s):
+
+${rows.map(formatProduct).join("\n")}`
+  );
+}
+async function handleGetProductById(input) {
+  const { productId } = input;
+  if (!productId) return textResponse2("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.");
+  }
+  const [row] = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
+    and(
+      eq(schema_exports.invoiceProducts.id, productId),
+      inArray(schema_exports.invoiceProducts.teamId, scope.teamIds)
+    )
+  ).limit(1);
+  if (!row) {
+    return textResponse2(
+      `Product ${productId} not found or you don't have access to it.`
+    );
+  }
+  return textResponse2(formatProduct(row));
+}
+async function loadProductInTeam(productId, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const [row] = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
+    and(
+      eq(schema_exports.invoiceProducts.id, productId),
+      inArray(schema_exports.invoiceProducts.teamId, accessibleTeamIds)
+    )
+  ).limit(1);
+  return row ?? null;
+}
+async function handleCreateProduct(input) {
+  const { name: name21, description, price, currency, unit } = input;
+  if (!name21 || name21.trim().length === 0) {
+    return textResponse2("Error: `name` is required.");
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const [created] = await db.insert(schema_exports.invoiceProducts).values({
+    teamId: resolved.teamId,
+    name: name21.trim(),
+    description: description ?? null,
+    price: price ?? null,
+    currency: currency ?? null,
+    unit: unit ?? null,
+    isActive: true,
+    lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).returning(PRODUCT_COLUMNS);
+  if (!created) return textResponse2("Failed to create product.");
+  return textResponse2(
+    `\u2705 **Product created**
+
+${formatProduct(created)}`
+  );
+}
+async function handleUpdateProduct(input) {
+  const { productId } = input;
+  if (!productId) return textResponse2("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(
+      `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.");
+    }
+    updates.name = input.name.trim();
+  }
+  if (input.description !== void 0) updates.description = input.description;
+  if (input.price !== void 0) updates.price = input.price;
+  if (input.currency !== void 0) updates.currency = input.currency;
+  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(
+      "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(
+    `\u2705 **Product updated**
+
+${formatProduct(updated)}
+Note: this only affects future invoices/quotes. Existing documents keep their line-item snapshots.`
+  );
+}
+async function handleArchiveProduct(input) {
+  const { productId, reason } = input;
+  if (!productId) return textResponse2("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(
+      `Product ${productId} not found, or it is not owned by this team.`
+    );
+  }
+  if (!existing.isActive) {
+    return textResponse2(
+      `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(
+    `\u2705 **Product archived** (hidden from new invoices/quotes; existing documents are untouched).
+
+${formatProduct(archived)}${reason ? `Reason: ${reason}
+` : ""}Reactivate it with update-product (isActive: true).`
+  );
+}
 
 // src/tools/teams.ts
 async function handleGetTeams() {
@@ -118496,7 +119059,7 @@ var EXT_MIME = {
   ppt: "application/vnd.ms-powerpoint",
   pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
-function textResponse2(text3) {
+function textResponse3(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function mimeFromName(name21) {
@@ -118577,12 +119140,12 @@ async function handleUploadTicketAttachment(input) {
     (v2) => typeof v2 === "string" && v2.trim().length > 0
   );
   if (sources.length === 0) {
-    return textResponse2(
+    return textResponse3(
       "Provide exactly one source: filePath (absolute local path), imageUrl, or base64Data."
     );
   }
   if (sources.length > 1) {
-    return textResponse2(
+    return textResponse3(
       "Provide only one source (filePath, imageUrl, or base64Data), not several."
     );
   }
@@ -118602,7 +119165,7 @@ async function handleUploadTicketAttachment(input) {
     } else if (input.imageUrl) {
       const res = await fetch(input.imageUrl);
       if (!res.ok) {
-        return textResponse2(
+        return textResponse3(
           `Could not download from URL: HTTP ${res.status}.`
         );
       }
@@ -118630,22 +119193,22 @@ async function handleUploadTicketAttachment(input) {
       }
     }
   } catch (error49) {
-    return textResponse2(
+    return textResponse3(
       `Failed to read the file: ${error49 instanceof Error ? error49.message : String(error49)}`
     );
   }
   if (buffer2.byteLength === 0) {
-    return textResponse2("The file is empty (0 bytes); nothing to upload.");
+    return textResponse3("The file is empty (0 bytes); nothing to upload.");
   }
   if (buffer2.byteLength > MAX_FILE_SIZE) {
-    return textResponse2(
+    return textResponse3(
       `File too large (${(buffer2.byteLength / 1024 / 1024).toFixed(
         1
       )} MB). Max: 25 MB.`
     );
   }
   if (!ALLOWED_MIME_TYPES.has(mimeType)) {
-    return textResponse2(
+    return textResponse3(
       `Unsupported file type: ${mimeType}. Allowed: JPEG, PNG, GIF, WebP, PDF, DOC(X), XLS(X), PPT(X), TXT, CSV.`
     );
   }
@@ -118658,7 +119221,7 @@ async function handleUploadTicketAttachment(input) {
       options: { contentType: mimeType, upsert: true }
     });
   } catch (error49) {
-    return textResponse2(
+    return textResponse3(
       `Upload failed: ${error49 instanceof Error ? error49.message : String(error49)}`
     );
   }
@@ -118681,7 +119244,7 @@ async function handleUploadTicketAttachment(input) {
     url3 = signed.url;
   } catch {
   }
-  return textResponse2(
+  return textResponse3(
     `\u{1F4CE} **Attached to ${ticket.ticketNumber}**
 File: ${fileName}
 Type: ${mimeType}
@@ -119017,11 +119580,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);
@@ -119067,6 +119630,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 textResponse4(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 textResponse4("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 textResponse4(
+      `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 textResponse4(
+      "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 textResponse4("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 textResponse4(
+      `\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 textResponse4(`Failed to update tag ${input.tagId}.`);
+  return textResponse4(
+    `\u2705 **Tag updated**
+
+${describeTag(updated)}
+
+Existing ticket/customer/project/transaction tag relations are preserved.`
+  );
+}
+async function handleDeleteTag(input) {
+  if (!input.tagId) return textResponse4("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 textResponse4(
+      `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 textResponse4(
+      `\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 textResponse4(
+      `\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 textResponse4(
+    `\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: textResponse4(
+          `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: textResponse4(
+        "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: textResponse4("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 textResponse4("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 textResponse4(
+      `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 textResponse4(
+      "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 textResponse4(
+    `\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 = [
@@ -119825,7 +120728,7 @@ ${tagErrors.map((e6) => `   \u2022 ${e6}`).join("\n")}
 }
 
 // src/server.ts
-var SERVER_VERSION = "3.4.0";
+var SERVER_VERSION = "3.5.0";
 function createMcpServer() {
   const server = new Server(
     {
@@ -119873,6 +120776,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)
@@ -119911,6 +120820,14 @@ function createMcpServer() {
           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)
@@ -119949,6 +120866,24 @@ function createMcpServer() {
           return await handleLinkDocumentToInvoice(
             asToolArgs(toolArgs)
           );
+        case "get-products":
+          return await handleGetProducts(asToolArgs(toolArgs));
+        case "get-product-by-id":
+          return await handleGetProductById(
+            asToolArgs(toolArgs)
+          );
+        case "create-product":
+          return await handleCreateProduct(
+            asToolArgs(toolArgs)
+          );
+        case "update-product":
+          return await handleUpdateProduct(
+            asToolArgs(toolArgs)
+          );
+        case "archive-product":
+          return await handleArchiveProduct(
+            asToolArgs(toolArgs)
+          );
         case "log-hours":
           return await handleLogHours(asToolArgs(toolArgs));
         case "get-github-file":