@mgsoftwarebv/mcp-server-bridge 3.4.1 → 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.",
@@ -107985,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}.`
     );
@@ -112565,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);
@@ -112585,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."}`
       }
     ]
   };
@@ -113104,6 +113268,108 @@ 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"];
@@ -119314,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);
@@ -119364,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 = [
@@ -120170,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)
@@ -120208,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)