@mgsoftwarebv/mcp-server-bridge 3.5.6 → 3.5.8

package/dist/index.js

@@ -103433,10 +103433,28 @@ var customerRecurringServices = pgTable(
     // Frozen RecurringContractTerms (notice period, minimum term, renewal
     // policy, cancellation effect, billing after cancellation, free notes).
     contractTerms: jsonb("contract_terms").$type(),
+    // Frozen ProductClause — customer-specific scope/limits snapshot.
+    clause: jsonb().$type(),
+    // Structured discount applied on top of catalog price.
+    discountType: text("discount_type"),
+    discountValue: numericCasted("discount_value", { precision: 10, scale: 2 }),
+    // Compact invoice line text (overrides name on draft invoices when set).
+    lineDescription: text("line_description"),
+    // Umbrella contract label for grouped billable lines on invoices.
+    umbrellaLabel: text("umbrella_label"),
+    // Pro-rata first invoice for yearly variants starting mid-period.
+    proRataFirstInvoice: boolean3("pro_rata_first_invoice").default(false).notNull(),
+    // End of billing/contract period for pro-rata (defaults to end of start year).
+    contractPeriodEnd: timestamp("contract_period_end", {
+      withTimezone: true,
+      mode: "string"
+    }),
     // --- Lifecycle ---
     // "active" | "paused" | "cancelled" | "ended"
     status: text().$type().default("active").notNull(),
     startDate: timestamp("start_date", { withTimezone: true, mode: "string" }),
+    // Planned end of the agreement (before cancellation/ended).
+    endDate: timestamp("end_date", { withTimezone: true, mode: "string" }),
     // Next renewal boundary (end of current covered term).
     renewalDate: timestamp("renewal_date", {
       withTimezone: true,
@@ -106677,7 +106695,7 @@ var TOOLS = [
   },
   {
     name: "get-invoices",
-    description: "List invoices with optional filtering by customer, status, or a search on invoice number / customer name. Use this to check whether a (draft) invoice already exists before linking a deliverables document to it with `invoiceId` on create-document or link-document-to-invoice.",
+    description: "List invoices with optional filtering by customer, status, or a search on invoice number / customer name. Use `get-invoice-by-id` for full detail including line items, product snapshots and linked documents. Use this listing to find a (draft) invoice before linking a deliverables document with `invoiceId` on create-document or link-document-to-invoice.",
     inputSchema: {
       type: "object",
       properties: {
@@ -106722,6 +106740,136 @@ var TOOLS = [
       required: ["documentId", "invoiceId"]
     }
   },
+  {
+    name: "get-invoice-by-id",
+    description: "Get a single invoice by UUID or invoice number (e.g. 260060). Returns status, customer, dates, currency, totals, all line items (compact description + extended product/variant/clause context) and linked documents. Use before editing draft line descriptions with update-invoice-lines.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        invoiceId: {
+          type: "string",
+          description: "Invoice UUID or invoice number"
+        }
+      },
+      required: ["invoiceId"]
+    }
+  },
+  {
+    name: "update-invoice",
+    description: "Update a DRAFT invoice. Only invoices still in status `draft` can be changed \u2014 sent/paid/unpaid/overdue invoices are immutable here. Editable fields: title (template.title), note, internalNote, dueDate, issueDate. Provide `lineItems` to REPLACE all items (totals recomputed; productId items are re-snapshotted with clause + pricing variant).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        invoiceId: { type: "string", description: "Invoice UUID or number" },
+        title: { type: "string", description: "Overrides template.title" },
+        note: {
+          type: ["string", "null"],
+          description: "Customer-facing note; null clears it."
+        },
+        internalNote: { type: ["string", "null"] },
+        dueDate: { type: ["string", "null"], description: "ISO date" },
+        issueDate: { type: ["string", "null"], description: "ISO date" },
+        lineItems: {
+          type: "array",
+          description: "Replaces ALL line items. Each: { name?, quantity?, unit?, price?, productId?, pricingOptionId?, prorate?, startDate?, periodEndDate? }.",
+          items: {
+            type: "object",
+            properties: {
+              name: { type: "string", description: "Compact line description" },
+              quantity: { type: "number" },
+              unit: { type: "string" },
+              price: { type: "number", description: "Unit price excl. VAT" },
+              productId: { type: "string" },
+              pricingOptionId: { type: "string" },
+              prorate: {
+                type: "boolean",
+                description: "Pro-rate yearly variant from startDate"
+              },
+              startDate: { type: "string", description: "ISO date for pro-rata" },
+              periodEndDate: { type: "string" }
+            }
+          }
+        }
+      },
+      required: ["invoiceId"]
+    }
+  },
+  {
+    name: "update-invoice-lines",
+    description: "Update specific line items on a DRAFT invoice without replacing the whole list. Address lines by zero-based `index`. Only provided fields change; clause/pricingOption/productId snapshots are preserved. Ideal for compacting factuurregel descriptions. Recomputes invoice totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        invoiceId: { type: "string", description: "Invoice UUID or number" },
+        lineItems: {
+          type: "array",
+          description: "Patches to apply. Each: { index, description?, quantity?, unit?, price? }.",
+          items: {
+            type: "object",
+            properties: {
+              index: {
+                type: "number",
+                description: "Zero-based line index"
+              },
+              description: {
+                type: "string",
+                description: "Compact factuurregel text (plain string)"
+              },
+              quantity: { type: "number" },
+              unit: { type: "string" },
+              price: { type: "number" }
+            },
+            required: ["index"]
+          }
+        }
+      },
+      required: ["invoiceId", "lineItems"]
+    }
+  },
+  {
+    name: "add-product-to-invoice",
+    description: "Add a catalog product as a new line item on a DRAFT invoice. Snapshots clause + chosen pricing variant onto the line. Only works on `draft` invoices. Supports optional pro-rata billing for yearly variants (prorate + startDate). Recomputes totals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        invoiceId: { type: "string", description: "Invoice UUID or number" },
+        productId: {
+          type: "string",
+          description: "Catalog product ID (see get-products)"
+        },
+        quantity: { type: "number", default: 1 },
+        customDescription: {
+          type: "string",
+          description: "Overrides the compact line description."
+        },
+        customPrice: {
+          type: "number",
+          description: "Overrides the unit price (excl. VAT)."
+        },
+        pricingOptionId: {
+          type: "string",
+          description: "Pricing variant id (monthly/yearly); defaults to product default."
+        },
+        prorate: {
+          type: "boolean",
+          description: "When true and a yearly variant is selected, price is pro-rated from startDate."
+        },
+        startDate: {
+          type: "string",
+          description: "ISO start date for pro-rata (required when prorate is true)."
+        },
+        periodEndDate: {
+          type: "string",
+          description: "Optional end of billing period for pro-rata (defaults to end of start year)."
+        }
+      },
+      required: ["invoiceId", "productId"]
+    }
+  },
   {
     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, usage stats, and structured package metadata (category, billingType, tier, optional add-on flag and includedItems). 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.",
@@ -107253,6 +107401,90 @@ var TOOLS = [
       },
       required: ["projectId", "directoryPath"]
     }
+  },
+  {
+    name: "get-customer-agreements",
+    description: "List per-customer product agreements (customer_recurring_services): custom price, discount, clause snapshot, umbrella label, billing cadence, start/end dates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Filter by customer UUID" },
+        status: {
+          type: "string",
+          enum: ["active", "paused", "cancelled", "ended"],
+          description: "Filter by agreement status"
+        }
+      }
+    }
+  },
+  {
+    name: "create-customer-agreement",
+    description: "Create a customer-specific product agreement between catalog and billing. Snapshots price, discount, clause and invoice line text without mutating the catalog product.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        customerId: { type: "string", description: "Customer UUID" },
+        productId: { type: "string", description: "Optional catalog product UUID" },
+        name: { type: "string", description: "Agreement name" },
+        description: { type: "string" },
+        price: { type: "number" },
+        billingInterval: { type: "string", enum: ["month", "year"] },
+        discountType: { type: "string", enum: ["percentage", "amount"] },
+        discountValue: { type: "number" },
+        discountDescription: { type: "string" },
+        lineDescription: {
+          type: "string",
+          description: "Compact invoice line text override"
+        },
+        umbrellaLabel: {
+          type: "string",
+          description: "Umbrella contract label for grouped invoice lines"
+        },
+        clause: productClauseProp,
+        startDate: { type: "string", description: "ISO start date" },
+        endDate: { type: "string", description: "ISO planned end date" },
+        contractPeriodEnd: {
+          type: "string",
+          description: "ISO period end for pro-rata calculations"
+        },
+        proRataFirstInvoice: { type: "boolean" }
+      },
+      required: ["customerId", "name"]
+    }
+  },
+  {
+    name: "update-customer-agreement",
+    description: "Update an existing customer product agreement by id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        teamId: teamIdProp,
+        id: { type: "string", description: "Agreement UUID" },
+        customerId: { type: "string" },
+        productId: { type: "string" },
+        name: { type: "string" },
+        description: { type: "string" },
+        price: { type: "number" },
+        billingInterval: { type: "string", enum: ["month", "year"] },
+        discountType: { type: "string", enum: ["percentage", "amount"] },
+        discountValue: { type: "number" },
+        discountDescription: { type: "string" },
+        lineDescription: { type: "string" },
+        umbrellaLabel: { type: "string" },
+        clause: productClauseProp,
+        startDate: { type: "string" },
+        endDate: { type: "string" },
+        contractPeriodEnd: { type: "string" },
+        proRataFirstInvoice: { type: "boolean" },
+        status: {
+          type: "string",
+          enum: ["active", "paused", "cancelled", "ended"]
+        }
+      },
+      required: ["id"]
+    }
   }
 ];
 var RESOURCES = [
@@ -108347,130 +108579,374 @@ The customer had no projects, tickets, invoices, quotations, documents, time ent
   );
 }
 
-// ../document/src/humanizer/rules.ts
-var REPLACEMENTS = [
-  // --- Dutch clichés ---
-  { pattern: /\bbovendien\b/gi, replacement: "daarnaast", rule: "nl-cliche" },
-  { pattern: /\btevens\b/gi, replacement: "ook", rule: "nl-cliche" },
-  { pattern: /\bkortom\b/gi, replacement: "samengevat", rule: "nl-cliche" },
-  { pattern: /\bnaadloze\b/gi, replacement: "soepele", rule: "nl-cliche" },
-  { pattern: /\bnaadloos\b/gi, replacement: "soepel", rule: "nl-cliche" },
-  { pattern: /\brobuuste\b/gi, replacement: "solide", rule: "nl-cliche" },
-  { pattern: /\brobuust\b/gi, replacement: "solide", rule: "nl-cliche" },
-  { pattern: /\bcruciale\b/gi, replacement: "belangrijke", rule: "nl-cliche" },
-  { pattern: /\bcruciaal\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
-  {
-    pattern: /\bessentiële\b/gi,
-    replacement: "belangrijke",
-    rule: "nl-cliche"
-  },
-  { pattern: /\bessentieel\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
-  {
-    pattern: /\been breed scala aan\b/gi,
-    replacement: "veel",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\boptimaal benutten\b/gi,
-    replacement: "goed benutten",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\bin de wereld van vandaag\b/gi,
-    replacement: "vandaag de dag",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\bin het huidige digitale tijdperk\b/gi,
-    replacement: "tegenwoordig",
-    rule: "nl-cliche"
-  },
-  {
-    pattern: /\bstate-of-the-art\b/gi,
-    replacement: "moderne",
-    rule: "nl-cliche"
-  },
-  // --- Double superlatives / intensifiers ---
-  { pattern: /\bzeer unieke?\b/gi, replacement: "unieke", rule: "superlative" },
-  { pattern: /\bheel erg\b/gi, replacement: "erg", rule: "superlative" },
-  {
-    pattern: /\babsoluut essentieel\b/gi,
-    replacement: "belangrijk",
-    rule: "superlative"
-  },
-  // --- English clichés ---
-  { pattern: /\bdelve into\b/gi, replacement: "look at", rule: "en-cliche" },
-  { pattern: /\bdelves into\b/gi, replacement: "looks at", rule: "en-cliche" },
-  {
-    pattern: /\bdelving into\b/gi,
-    replacement: "looking at",
-    rule: "en-cliche"
-  },
-  { pattern: /\bleveraging\b/gi, replacement: "using", rule: "en-cliche" },
-  { pattern: /\bleverages\b/gi, replacement: "uses", rule: "en-cliche" },
-  { pattern: /\bleverage\b/gi, replacement: "use", rule: "en-cliche" },
-  { pattern: /\bseamlessly\b/gi, replacement: "smoothly", rule: "en-cliche" },
-  { pattern: /\bseamless\b/gi, replacement: "smooth", rule: "en-cliche" },
-  { pattern: /\bfurthermore\b/gi, replacement: "also", rule: "en-cliche" },
-  { pattern: /\bmoreover\b/gi, replacement: "also", rule: "en-cliche" },
-  { pattern: /\butilizes\b/gi, replacement: "uses", rule: "en-cliche" },
-  { pattern: /\butilizing\b/gi, replacement: "using", rule: "en-cliche" },
-  { pattern: /\butilize\b/gi, replacement: "use", rule: "en-cliche" },
-  { pattern: /\bcutting-edge\b/gi, replacement: "modern", rule: "en-cliche" },
-  { pattern: /\bgame-changer\b/gi, replacement: "big step", rule: "en-cliche" },
-  { pattern: /\bembark on\b/gi, replacement: "start", rule: "en-cliche" },
-  {
-    pattern: /\ba wide range of\b/gi,
-    replacement: "many",
-    rule: "en-cliche"
-  },
-  {
-    pattern: /\bin today's (fast-paced )?world\b/gi,
-    replacement: "today",
-    rule: "en-cliche"
-  },
-  {
-    pattern: /\bin this digital age\b/gi,
-    replacement: "today",
-    rule: "en-cliche"
-  }
-];
-var FILLER_PHRASES = [
-  {
-    pattern: /(^|(?<=[.!?]\s))het is belangrijk om (te vermelden|op te merken|te benadrukken) dat\s+/gi,
-    rule: "nl-filler"
-  },
-  {
-    pattern: /(^|(?<=[.!?]\s))het is goed om te weten dat\s+/gi,
-    rule: "nl-filler"
-  },
-  {
-    pattern: /(^|(?<=[.!?]\s))zoals eerder (vermeld|genoemd|aangegeven),?\s+/gi,
-    rule: "nl-filler"
-  },
-  {
-    pattern: /(^|(?<=[.!?]\s))it('|’)s worth noting that\s+/gi,
-    rule: "en-filler"
-  },
-  {
-    pattern: /(^|(?<=[.!?]\s))it is (important|worth mentioning) (to note )?that\s+/gi,
-    rule: "en-filler"
-  },
-  {
-    pattern: /(^|(?<=[.!?]\s))as (previously )?mentioned( before| earlier)?,?\s+/gi,
-    rule: "en-filler"
-  },
-  { pattern: /(^|(?<=[.!?]\s))needless to say,?\s+/gi, rule: "en-filler" }
-];
-function matchCase(replacement, original) {
-  if (!original.length || !replacement.length) return replacement;
-  const first = original[0];
-  if (first === first.toUpperCase() && first !== first.toLowerCase()) {
-    return replacement[0].toUpperCase() + replacement.slice(1);
-  }
-  return replacement;
+// ../invoice/src/utils/product-clause.ts
+function trimToNull(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
 }
-function capitalizeSentenceStarts(text3) {
+function parseStringList(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    const label = trimToNull(entry);
+    if (label) out.push(label);
+  }
+  return out;
+}
+function parseLimits(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const hoursRaw = raw.includedHoursPerMonth;
+  let includedHoursPerMonth = null;
+  if (typeof hoursRaw === "number" && Number.isFinite(hoursRaw)) {
+    includedHoursPerMonth = hoursRaw;
+  } else if (typeof hoursRaw === "string" && hoursRaw.trim() !== "") {
+    const parsed = Number(hoursRaw);
+    if (Number.isFinite(parsed)) includedHoursPerMonth = parsed;
+  }
+  const rollover = typeof raw.rollover === "boolean" ? raw.rollover : null;
+  const limits = {
+    includedHoursPerMonth,
+    rollover,
+    minimumBillingUnitExtraWork: trimToNull(raw.minimumBillingUnitExtraWork),
+    responseTime: trimToNull(raw.responseTime),
+    supportLevel: trimToNull(raw.supportLevel)
+  };
+  return isLimitsEmpty(limits) ? null : limits;
+}
+function isLimitsEmpty(limits) {
+  if (!limits) return true;
+  return limits.includedHoursPerMonth == null && limits.rollover == null && !limits.minimumBillingUnitExtraWork && !limits.responseTime && !limits.supportLevel;
+}
+function parseProductClause(value) {
+  if (value == null) return null;
+  if (typeof value !== "object" || Array.isArray(value)) return null;
+  const raw = value;
+  const clause = {
+    commercialDescription: trimToNull(raw.commercialDescription),
+    includedScope: parseStringList(raw.includedScope),
+    excludedScope: parseStringList(raw.excludedScope),
+    limits: parseLimits(raw.limits),
+    customerValue: trimToNull(raw.customerValue),
+    extraWorkConditions: trimToNull(raw.extraWorkConditions)
+  };
+  return isClauseEmpty(clause) ? null : clause;
+}
+function isClauseEmpty(clause) {
+  if (!clause) return true;
+  return !clause.commercialDescription && (clause.includedScope?.length ?? 0) === 0 && (clause.excludedScope?.length ?? 0) === 0 && isLimitsEmpty(clause.limits) && !clause.customerValue && !clause.extraWorkConditions;
+}
+function serializeProductClause(clause) {
+  if (clause == null) return null;
+  const parsed = parseProductClause(clause);
+  if (!parsed) return null;
+  const out = {};
+  if (parsed.commercialDescription) {
+    out.commercialDescription = parsed.commercialDescription;
+  }
+  if (parsed.includedScope && parsed.includedScope.length > 0) {
+    out.includedScope = parsed.includedScope;
+  }
+  if (parsed.excludedScope && parsed.excludedScope.length > 0) {
+    out.excludedScope = parsed.excludedScope;
+  }
+  if (!isLimitsEmpty(parsed.limits)) {
+    const limits = parsed.limits;
+    const cleanedLimits = {};
+    if (limits.includedHoursPerMonth != null) {
+      cleanedLimits.includedHoursPerMonth = limits.includedHoursPerMonth;
+    }
+    if (limits.rollover != null) cleanedLimits.rollover = limits.rollover;
+    if (limits.minimumBillingUnitExtraWork) {
+      cleanedLimits.minimumBillingUnitExtraWork = limits.minimumBillingUnitExtraWork;
+    }
+    if (limits.responseTime) cleanedLimits.responseTime = limits.responseTime;
+    if (limits.supportLevel) cleanedLimits.supportLevel = limits.supportLevel;
+    out.limits = cleanedLimits;
+  }
+  if (parsed.customerValue) out.customerValue = parsed.customerValue;
+  if (parsed.extraWorkConditions) {
+    out.extraWorkConditions = parsed.extraWorkConditions;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+function clauseLimitLines(limits) {
+  if (isLimitsEmpty(limits) || !limits) return [];
+  const lines = [];
+  if (limits.includedHoursPerMonth != null) {
+    lines.push(`Inbegrepen uren per maand: ${limits.includedHoursPerMonth}`);
+  }
+  if (limits.rollover != null) {
+    lines.push(
+      limits.rollover ? "Niet-gebruikte uren schuiven door naar de volgende maand" : "Niet-gebruikte uren vervallen aan het einde van de maand"
+    );
+  }
+  if (limits.minimumBillingUnitExtraWork) {
+    lines.push(
+      `Minimale facturatie-eenheid meerwerk: ${limits.minimumBillingUnitExtraWork}`
+    );
+  }
+  if (limits.supportLevel) lines.push(`Supportniveau: ${limits.supportLevel}`);
+  if (limits.responseTime) lines.push(`Responstijd: ${limits.responseTime}`);
+  return lines;
+}
+function clauseSummaryLines(clause) {
+  const parsed = parseProductClause(clause);
+  if (!parsed) return [];
+  const lines = [];
+  if (parsed.commercialDescription) {
+    lines.push(parsed.commercialDescription);
+  }
+  if (parsed.includedScope?.length) {
+    lines.push(`Inbegrepen: ${parsed.includedScope.join("; ")}`);
+  }
+  if (parsed.excludedScope?.length) {
+    lines.push(`Niet inbegrepen: ${parsed.excludedScope.join("; ")}`);
+  }
+  lines.push(...clauseLimitLines(parsed.limits));
+  if (parsed.customerValue) {
+    lines.push(`Klantwaarde: ${parsed.customerValue}`);
+  }
+  if (parsed.extraWorkConditions) {
+    lines.push(`Meerwerk: ${parsed.extraWorkConditions}`);
+  }
+  return lines;
+}
+
+// src/tools/customer-agreements.ts
+function textResponse2(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+function formatAgreement(row) {
+  const parts = [
+    `**${row.name}** (${row.status})`,
+    `id: ${row.id}`,
+    `customerId: ${row.customerId}`,
+    row.productId ? `productId: ${row.productId}` : null,
+    row.price != null ? `price: ${row.price} ${row.currency ?? "EUR"}` : null,
+    row.billingInterval ? `billing: ${row.billingInterval}` : null,
+    row.discountType && row.discountValue != null ? `discount: ${row.discountType} ${row.discountValue}` : null,
+    row.lineDescription ? `invoice line: ${row.lineDescription}` : null,
+    row.umbrellaLabel ? `umbrella: ${row.umbrellaLabel}` : null,
+    row.startDate ? `start: ${row.startDate}` : null,
+    row.endDate ? `end: ${row.endDate}` : null,
+    row.proRataFirstInvoice ? "pro-rata first invoice: yes" : null
+  ].filter(Boolean);
+  return parts.join("\n");
+}
+async function handleGetCustomerAgreements(input) {
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const conditions = [inArray(schema_exports.customerRecurringServices.teamId, scope.teamIds)];
+  if (input.customerId) {
+    conditions.push(
+      eq(schema_exports.customerRecurringServices.customerId, input.customerId)
+    );
+  }
+  if (input.status) {
+    conditions.push(eq(schema_exports.customerRecurringServices.status, input.status));
+  }
+  const rows = await db.select().from(schema_exports.customerRecurringServices).where(and(...conditions)).orderBy(desc(schema_exports.customerRecurringServices.createdAt)).limit(50);
+  if (rows.length === 0) {
+    return textResponse2("No customer agreements found.");
+  }
+  return textResponse2(rows.map(formatAgreement).join("\n\n---\n\n"));
+}
+async function handleCreateCustomerAgreement(input) {
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const teamId = scope.teamIds[0];
+  const [row] = await db.insert(schema_exports.customerRecurringServices).values({
+    teamId,
+    customerId: input.customerId,
+    productId: input.productId ?? null,
+    name: input.name,
+    description: input.description ?? null,
+    price: input.price ?? null,
+    billingInterval: input.billingInterval ?? null,
+    discountType: input.discountType ?? null,
+    discountValue: input.discountValue ?? null,
+    discountDescription: input.discountDescription ?? null,
+    lineDescription: input.lineDescription ?? null,
+    umbrellaLabel: input.umbrellaLabel ?? null,
+    clause: serializeProductClause(input.clause ?? null),
+    startDate: input.startDate ?? null,
+    endDate: input.endDate ?? null,
+    contractPeriodEnd: input.contractPeriodEnd ?? null,
+    proRataFirstInvoice: input.proRataFirstInvoice ?? false,
+    status: "active"
+  }).returning();
+  return textResponse2(`Created customer agreement:
+
+${formatAgreement(row)}`);
+}
+async function handleUpdateCustomerAgreement(input) {
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  const teamId = scope.teamIds[0];
+  const patch = {
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (input.name !== void 0) patch.name = input.name;
+  if (input.description !== void 0) patch.description = input.description;
+  if (input.price !== void 0) patch.price = input.price;
+  if (input.billingInterval !== void 0)
+    patch.billingInterval = input.billingInterval;
+  if (input.discountType !== void 0) patch.discountType = input.discountType;
+  if (input.discountValue !== void 0) patch.discountValue = input.discountValue;
+  if (input.discountDescription !== void 0)
+    patch.discountDescription = input.discountDescription;
+  if (input.lineDescription !== void 0)
+    patch.lineDescription = input.lineDescription;
+  if (input.umbrellaLabel !== void 0) patch.umbrellaLabel = input.umbrellaLabel;
+  if (input.clause !== void 0)
+    patch.clause = serializeProductClause(input.clause ?? null);
+  if (input.startDate !== void 0) patch.startDate = input.startDate;
+  if (input.endDate !== void 0) patch.endDate = input.endDate;
+  if (input.contractPeriodEnd !== void 0)
+    patch.contractPeriodEnd = input.contractPeriodEnd;
+  if (input.proRataFirstInvoice !== void 0)
+    patch.proRataFirstInvoice = input.proRataFirstInvoice;
+  if (input.status !== void 0) patch.status = input.status;
+  const [row] = await db.update(schema_exports.customerRecurringServices).set(patch).where(
+    and(
+      eq(schema_exports.customerRecurringServices.id, input.id),
+      eq(schema_exports.customerRecurringServices.teamId, teamId)
+    )
+  ).returning();
+  if (!row) {
+    return textResponse2("Agreement not found.");
+  }
+  return textResponse2(`Updated customer agreement:
+
+${formatAgreement(row)}`);
+}
+
+// ../document/src/humanizer/rules.ts
+var REPLACEMENTS = [
+  // --- Dutch clichés ---
+  { pattern: /\bbovendien\b/gi, replacement: "daarnaast", rule: "nl-cliche" },
+  { pattern: /\btevens\b/gi, replacement: "ook", rule: "nl-cliche" },
+  { pattern: /\bkortom\b/gi, replacement: "samengevat", rule: "nl-cliche" },
+  { pattern: /\bnaadloze\b/gi, replacement: "soepele", rule: "nl-cliche" },
+  { pattern: /\bnaadloos\b/gi, replacement: "soepel", rule: "nl-cliche" },
+  { pattern: /\brobuuste\b/gi, replacement: "solide", rule: "nl-cliche" },
+  { pattern: /\brobuust\b/gi, replacement: "solide", rule: "nl-cliche" },
+  { pattern: /\bcruciale\b/gi, replacement: "belangrijke", rule: "nl-cliche" },
+  { pattern: /\bcruciaal\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
+  {
+    pattern: /\bessentiële\b/gi,
+    replacement: "belangrijke",
+    rule: "nl-cliche"
+  },
+  { pattern: /\bessentieel\b/gi, replacement: "belangrijk", rule: "nl-cliche" },
+  {
+    pattern: /\been breed scala aan\b/gi,
+    replacement: "veel",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\boptimaal benutten\b/gi,
+    replacement: "goed benutten",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\bin de wereld van vandaag\b/gi,
+    replacement: "vandaag de dag",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\bin het huidige digitale tijdperk\b/gi,
+    replacement: "tegenwoordig",
+    rule: "nl-cliche"
+  },
+  {
+    pattern: /\bstate-of-the-art\b/gi,
+    replacement: "moderne",
+    rule: "nl-cliche"
+  },
+  // --- Double superlatives / intensifiers ---
+  { pattern: /\bzeer unieke?\b/gi, replacement: "unieke", rule: "superlative" },
+  { pattern: /\bheel erg\b/gi, replacement: "erg", rule: "superlative" },
+  {
+    pattern: /\babsoluut essentieel\b/gi,
+    replacement: "belangrijk",
+    rule: "superlative"
+  },
+  // --- English clichés ---
+  { pattern: /\bdelve into\b/gi, replacement: "look at", rule: "en-cliche" },
+  { pattern: /\bdelves into\b/gi, replacement: "looks at", rule: "en-cliche" },
+  {
+    pattern: /\bdelving into\b/gi,
+    replacement: "looking at",
+    rule: "en-cliche"
+  },
+  { pattern: /\bleveraging\b/gi, replacement: "using", rule: "en-cliche" },
+  { pattern: /\bleverages\b/gi, replacement: "uses", rule: "en-cliche" },
+  { pattern: /\bleverage\b/gi, replacement: "use", rule: "en-cliche" },
+  { pattern: /\bseamlessly\b/gi, replacement: "smoothly", rule: "en-cliche" },
+  { pattern: /\bseamless\b/gi, replacement: "smooth", rule: "en-cliche" },
+  { pattern: /\bfurthermore\b/gi, replacement: "also", rule: "en-cliche" },
+  { pattern: /\bmoreover\b/gi, replacement: "also", rule: "en-cliche" },
+  { pattern: /\butilizes\b/gi, replacement: "uses", rule: "en-cliche" },
+  { pattern: /\butilizing\b/gi, replacement: "using", rule: "en-cliche" },
+  { pattern: /\butilize\b/gi, replacement: "use", rule: "en-cliche" },
+  { pattern: /\bcutting-edge\b/gi, replacement: "modern", rule: "en-cliche" },
+  { pattern: /\bgame-changer\b/gi, replacement: "big step", rule: "en-cliche" },
+  { pattern: /\bembark on\b/gi, replacement: "start", rule: "en-cliche" },
+  {
+    pattern: /\ba wide range of\b/gi,
+    replacement: "many",
+    rule: "en-cliche"
+  },
+  {
+    pattern: /\bin today's (fast-paced )?world\b/gi,
+    replacement: "today",
+    rule: "en-cliche"
+  },
+  {
+    pattern: /\bin this digital age\b/gi,
+    replacement: "today",
+    rule: "en-cliche"
+  }
+];
+var FILLER_PHRASES = [
+  {
+    pattern: /(^|(?<=[.!?]\s))het is belangrijk om (te vermelden|op te merken|te benadrukken) dat\s+/gi,
+    rule: "nl-filler"
+  },
+  {
+    pattern: /(^|(?<=[.!?]\s))het is goed om te weten dat\s+/gi,
+    rule: "nl-filler"
+  },
+  {
+    pattern: /(^|(?<=[.!?]\s))zoals eerder (vermeld|genoemd|aangegeven),?\s+/gi,
+    rule: "nl-filler"
+  },
+  {
+    pattern: /(^|(?<=[.!?]\s))it('|’)s worth noting that\s+/gi,
+    rule: "en-filler"
+  },
+  {
+    pattern: /(^|(?<=[.!?]\s))it is (important|worth mentioning) (to note )?that\s+/gi,
+    rule: "en-filler"
+  },
+  {
+    pattern: /(^|(?<=[.!?]\s))as (previously )?mentioned( before| earlier)?,?\s+/gi,
+    rule: "en-filler"
+  },
+  { pattern: /(^|(?<=[.!?]\s))needless to say,?\s+/gi, rule: "en-filler" }
+];
+function matchCase(replacement, original) {
+  if (!original.length || !replacement.length) return replacement;
+  const first = original[0];
+  if (first === first.toUpperCase() && first !== first.toLowerCase()) {
+    return replacement[0].toUpperCase() + replacement.slice(1);
+  }
+  return replacement;
+}
+function capitalizeSentenceStarts(text3) {
   return text3.replace(/^([a-zà-ÿ])/u, (c6) => c6.toUpperCase()).replace(/([.!?]\s+)([a-zà-ÿ])/gu, (_m5, sep4, c6) => sep4 + c6.toUpperCase());
 }
 function humanizeText(input) {
@@ -113520,31 +113996,391 @@ async function handleLogHours(input) {
 
 `;
   }
-  responseText += `\u{1F4CB} **Entry Details:**
-`;
-  responseText += `   \u2022 Project: ${project ? project.name : "(No project assigned)"}
-`;
-  if (ticket)
-    responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
-`;
-  responseText += `   \u2022 Description: ${workDescription}
-`;
-  responseText += `   \u2022 ${wasUpdated ? "Added" : "Estimated"} Hours: ${estimatedHours}h (${Math.floor(estimatedHours)}h ${Math.round(estimatedHours % 1 * 60)}m)
-`;
-  responseText += `   \u2022 Status: DRAFT (not billed yet)
-`;
-  responseText += `   \u2022 Entry ID: ${agendaEntry.id}
-
-`;
-  if (chatContextSummary) {
-    responseText += `\u{1F4CA} **Work Context:**
-`;
-    responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
-
-`;
+  responseText += `\u{1F4CB} **Entry Details:**
+`;
+  responseText += `   \u2022 Project: ${project ? project.name : "(No project assigned)"}
+`;
+  if (ticket)
+    responseText += `   \u2022 Ticket: ${ticket.title} (${ticket.status})
+`;
+  responseText += `   \u2022 Description: ${workDescription}
+`;
+  responseText += `   \u2022 ${wasUpdated ? "Added" : "Estimated"} Hours: ${estimatedHours}h (${Math.floor(estimatedHours)}h ${Math.round(estimatedHours % 1 * 60)}m)
+`;
+  responseText += `   \u2022 Status: DRAFT (not billed yet)
+`;
+  responseText += `   \u2022 Entry ID: ${agendaEntry.id}
+
+`;
+  if (chatContextSummary) {
+    responseText += `\u{1F4CA} **Work Context:**
+`;
+    responseText += `${chatContextSummary.substring(0, 200)}${chatContextSummary.length > 200 ? "..." : ""}
+
+`;
+  }
+  responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
+  return { content: [{ type: "text", text: responseText }] };
+}
+
+// ../invoice/src/utils/included-items.ts
+function parseIncludedItems(value) {
+  if (value == null) return null;
+  if (!Array.isArray(value)) return null;
+  const items = [];
+  for (const entry of value) {
+    if (typeof entry === "string") {
+      const label = entry.trim();
+      if (label) items.push({ label });
+      continue;
+    }
+    if (entry && typeof entry === "object" && "label" in entry) {
+      const raw = entry;
+      const label = String(raw.label ?? "").trim();
+      if (!label) continue;
+      const billable = raw.billable === false ? false : raw.billable === true ? true : void 0;
+      const rawPrice = raw.price;
+      const price = typeof rawPrice === "number" && Number.isFinite(rawPrice) ? rawPrice : typeof rawPrice === "string" && rawPrice.trim() !== "" ? Number(rawPrice) : null;
+      items.push({
+        label,
+        productId: typeof raw.productId === "string" ? raw.productId : null,
+        ...billable !== void 0 ? { billable } : {},
+        ...price != null && Number.isFinite(price) ? { price } : {},
+        ...typeof raw.pricingOptionId === "string" ? { pricingOptionId: raw.pricingOptionId } : {}
+      });
+    }
+  }
+  return items.length > 0 ? items : null;
+}
+function serializeIncludedItems(items) {
+  if (items == null) return null;
+  const cleaned = items.map((item) => {
+    const out = { label: item.label.trim() };
+    if (item.productId) out.productId = item.productId;
+    if (item.billable === false) out.billable = false;
+    else if (item.billable === true) out.billable = true;
+    if (item.price != null && Number.isFinite(item.price)) out.price = item.price;
+    if (item.pricingOptionId) out.pricingOptionId = item.pricingOptionId;
+    return out;
+  }).filter((item) => item.label.length > 0);
+  return cleaned.length > 0 ? cleaned : null;
+}
+function includedItemLabels(items) {
+  const parsed = items ? serializeIncludedItems(items) : null;
+  if (!parsed?.length) return null;
+  return parsed.map((item) => item.label);
+}
+
+// ../invoice/src/utils/finalize-line-items.ts
+function billableLineTotal(item) {
+  if (item.billable === false) return 0;
+  const price = item.price ?? 0;
+  const quantity = item.quantity ?? 0;
+  return price * quantity;
+}
+
+// ../invoice/src/utils/product-options.ts
+function findOption(group3, optionId) {
+  if (!optionId) return void 0;
+  return group3.options?.find((option) => option.id === optionId);
+}
+function buildDefaultConfiguration(product) {
+  const groups = product.options ?? [];
+  return {
+    selections: groups.map((group3) => {
+      if (group3.type === "quantity") {
+        return {
+          groupId: group3.id,
+          type: "quantity",
+          quantity: group3.defaultQuantity ?? group3.min ?? 0
+        };
+      }
+      if (group3.type === "single_choice") {
+        const defaultOption = group3.options?.find((option) => option.selectedByDefault) ?? group3.options?.[0];
+        return {
+          groupId: group3.id,
+          type: "single_choice",
+          optionId: defaultOption?.id ?? null
+        };
+      }
+      return {
+        groupId: group3.id,
+        type: "addon",
+        optionIds: group3.options?.filter((option) => option.selectedByDefault).map((option) => option.id) ?? []
+      };
+    })
+  };
+}
+function computeConfiguredPrice(product, configuration) {
+  const base = product.price ?? 0;
+  const groups = product.options ?? [];
+  if (!configuration || groups.length === 0) {
+    return base;
+  }
+  let extra = 0;
+  for (const group3 of groups) {
+    const selection = configuration.selections.find(
+      (item) => item.groupId === group3.id
+    );
+    if (!selection) continue;
+    if (group3.type === "quantity" && selection.type === "quantity") {
+      const clamped = clampQuantity(selection.quantity, group3);
+      extra += clamped * (group3.pricePerUnit ?? 0);
+      continue;
+    }
+    if (group3.type === "single_choice" && selection.type === "single_choice") {
+      const option = findOption(group3, selection.optionId);
+      extra += option?.price ?? 0;
+      continue;
+    }
+    if (group3.type === "addon" && selection.type === "addon") {
+      for (const optionId of selection.optionIds) {
+        const option = findOption(group3, optionId);
+        extra += option?.price ?? 0;
+      }
+    }
+  }
+  return base + extra;
+}
+function clampQuantity(quantity, group3) {
+  const value = Number.isFinite(quantity) ? quantity : 0;
+  const min = group3.min ?? 0;
+  const max = group3.max;
+  const lower = Math.max(value, min);
+  return max != null ? Math.min(lower, max) : lower;
+}
+
+// ../invoice/src/utils/pricing-options.ts
+function defaultMonthsCovered(interval2) {
+  return interval2 === "year" ? 12 : 1;
+}
+function formatRecurringNote(option) {
+  const period = option.billingInterval === "year" ? "per jaar" : "per maand";
+  const bits = [`${option.label} (${period})`];
+  if (option.discountDescription) bits.push(option.discountDescription);
+  const contract = option.contract;
+  const terms = [];
+  if (contract?.minimumTermMonths) {
+    terms.push(`min. looptijd ${contract.minimumTermMonths} mnd`);
+  }
+  if (contract?.noticePeriodDays) {
+    terms.push(`opzegtermijn ${contract.noticePeriodDays} dagen`);
+  }
+  if (contract?.renewalPolicy === "auto_renew") {
+    terms.push("stilzwijgend verlengd");
+  }
+  if (terms.length) bits.push(terms.join(", "));
+  return bits.join(" \xB7 ");
+}
+function resolveDefaultPricingOption(options, defaultId) {
+  if (!options || options.length === 0) return null;
+  if (defaultId) {
+    const found = options.find((o3) => o3.id === defaultId);
+    if (found) return found;
+  }
+  return options[0] ?? null;
+}
+function effectivePricingOptions(product) {
+  if (product.pricingOptions && product.pricingOptions.length > 0) {
+    return product.pricingOptions;
+  }
+  const interval2 = product.billingType === "yearly" ? "year" : product.billingType === "monthly" ? "month" : null;
+  if (interval2 && product.price != null) {
+    return [
+      {
+        id: interval2,
+        label: interval2 === "year" ? "Jaarlijks" : "Maandelijks",
+        billingInterval: interval2,
+        price: product.price,
+        monthsCovered: defaultMonthsCovered(interval2)
+      }
+    ];
+  }
+  return [];
+}
+function endOfUtcYear(iso) {
+  const date10 = new Date(iso);
+  if (Number.isNaN(date10.getTime())) return iso;
+  return new Date(
+    Date.UTC(date10.getUTCFullYear(), 11, 31, 23, 59, 59, 999)
+  ).toISOString();
+}
+function countInclusiveMonths(startIso, endIso) {
+  const start = new Date(startIso);
+  const end = new Date(endIso);
+  if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) return 0;
+  if (end.getTime() < start.getTime()) return 0;
+  return (end.getUTCFullYear() - start.getUTCFullYear()) * 12 + (end.getUTCMonth() - start.getUTCMonth()) + 1;
+}
+function computeProRata(input) {
+  if (!input.startDate) return null;
+  const start = new Date(input.startDate);
+  if (Number.isNaN(start.getTime())) return null;
+  const monthsInPeriod = input.monthsInPeriod != null && input.monthsInPeriod > 0 ? Math.round(input.monthsInPeriod) : 12;
+  const periodStart = input.startDate;
+  const periodEnd = input.periodEndDate ?? endOfUtcYear(input.startDate);
+  const end = new Date(periodEnd);
+  if (Number.isNaN(end.getTime())) return null;
+  let months2 = countInclusiveMonths(periodStart, periodEnd);
+  months2 = Math.min(Math.max(months2, 1), monthsInPeriod);
+  const fraction = months2 / monthsInPeriod;
+  const amount = Math.round(input.pricePerPeriod * fraction * 100) / 100;
+  return { months: months2, fraction, amount, periodStart, periodEnd };
+}
+
+// src/tools/invoice-line-util.ts
+function round2(n3) {
+  return Math.round(n3 * 100) / 100;
+}
+function lineFinancials(quantity, price, defaults) {
+  const lineTotal = quantity * price;
+  return {
+    vat: defaults.includeVat ? round2(lineTotal * (defaults.vatRate / 100)) : void 0,
+    tax: defaults.includeTax ? round2(lineTotal * (defaults.taxRate / 100)) : void 0
+  };
+}
+function computeInvoiceTotals(items, defaults, discount = 0) {
+  const subtotal = items.reduce(
+    (sum, i6) => sum + billableLineTotal(i6),
+    0
+  );
+  const vat = defaults.includeVat ? subtotal * (defaults.vatRate / 100) : 0;
+  const tax = defaults.includeTax ? subtotal * (defaults.taxRate / 100) : 0;
+  const safeDiscount = defaults.includeDiscount ? discount ?? 0 : 0;
+  const amount = subtotal + vat + tax - safeDiscount;
+  return {
+    subtotal: round2(subtotal),
+    vat: round2(vat),
+    tax: round2(tax),
+    amount: round2(amount)
+  };
+}
+function templateDefaultsFromInvoice(template, currency) {
+  const t8 = template ?? {};
+  return {
+    currency: t8.currency || currency || "EUR",
+    vatRate: t8.vatRate ?? 21,
+    taxRate: t8.taxRate ?? 0,
+    includeVat: t8.includeVat ?? true,
+    includeTax: t8.includeTax ?? false,
+    includeDiscount: t8.includeDiscount ?? false,
+    includeDecimals: t8.includeDecimals ?? true,
+    includeUnits: t8.includeUnits ?? true,
+    raw: t8
+  };
+}
+function plainTextFromLineItemName(name21) {
+  if (typeof name21 === "string") return name21.trim();
+  if (!name21 || typeof name21 !== "object") return "";
+  const parts = [];
+  const walk = (node) => {
+    if (!node || typeof node !== "object") return;
+    const n3 = node;
+    if (typeof n3.text === "string") parts.push(n3.text);
+    if (Array.isArray(n3.content)) n3.content.forEach(walk);
+  };
+  walk(name21);
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function resolvePricingOption(product, pricingOptionId) {
+  const options = effectivePricingOptions(product);
+  if (options.length === 0) return null;
+  if (pricingOptionId) {
+    const found = options.find((o3) => o3.id === pricingOptionId);
+    if (found) return found;
+  }
+  return resolveDefaultPricingOption(options, product.defaultPricingOptionId);
+}
+function compactLineDescription(product, override) {
+  if (override?.trim()) return override.trim();
+  const clause = parseProductClause(product.clause);
+  if (clause?.commercialDescription) return clause.commercialDescription;
+  return product.name;
+}
+function buildInvoiceLineFromProduct(product, opts, defaults) {
+  const quantity = opts.quantity ?? 1;
+  const pricingOption = resolvePricingOption(product, opts.pricingOptionId);
+  const clause = serializeProductClause(product.clause);
+  let configuration;
+  let price = opts.customPrice ?? product.price ?? 0;
+  if (product.isConfigurable && product.options) {
+    const groups = product.options;
+    if (groups?.length) {
+      const defaultConfig = buildDefaultConfiguration({
+        ...product,
+        options: groups
+      });
+      configuration = defaultConfig;
+      price = computeConfiguredPrice(
+        product,
+        defaultConfig
+      );
+    }
+  }
+  if (pricingOption && !(product.isConfigurable && product.options)) {
+    price = pricingOption.price;
+  }
+  if (opts.customPrice != null) price = opts.customPrice;
+  let proRata = null;
+  if (opts.prorate && pricingOption?.billingInterval === "year" && opts.startDate) {
+    const result = computeProRata({
+      pricePerPeriod: price,
+      startDate: opts.startDate,
+      periodEndDate: opts.periodEndDate,
+      monthsInPeriod: pricingOption.monthsCovered ?? 12
+    });
+    if (result) {
+      price = result.amount;
+      proRata = {
+        months: result.months,
+        fraction: result.fraction,
+        periodStart: result.periodStart,
+        periodEnd: result.periodEnd
+      };
+    }
+  }
+  const { vat, tax } = lineFinancials(quantity, price, defaults);
+  return {
+    name: compactLineDescription(product, opts.customDescription),
+    quantity,
+    unit: product.unit || void 0,
+    price,
+    vat,
+    tax,
+    productId: product.id,
+    configuration,
+    clause,
+    pricingOption: pricingOption ?? null,
+    includedItems: serializeIncludedItems(parseIncludedItems(product.includedItems)),
+    billable: opts.billable === false ? false : true,
+    groupLabel: opts.groupLabel ?? null,
+    proRata
+  };
+}
+function formatLineItemDetail(line2, index2) {
+  const description = plainTextFromLineItemName(line2.name) || "(no description)";
+  const lineTotal = round2((line2.quantity ?? 0) * (line2.price ?? 0));
+  const parts = [
+    `[${index2}] **${description}**`,
+    `  qty=${line2.quantity ?? 0}${line2.unit ? ` ${line2.unit}` : ""} \xD7 ${line2.price ?? 0} = ${lineTotal}`
+  ];
+  if (line2.productId) parts.push(`  productId: ${line2.productId}`);
+  if (line2.pricingOption) {
+    parts.push(`  variant: ${formatRecurringNote(line2.pricingOption)}`);
+  }
+  if (line2.proRata) {
+    parts.push(
+      `  pro-rata: ${line2.proRata.months} months (${Math.round(line2.proRata.fraction * 100)}%)`
+    );
   }
-  responseText += `\u2705 Time entry ${wasUpdated ? "updated" : "created"} and ready for review in the agenda!`;
-  return { content: [{ type: "text", text: responseText }] };
+  if (line2.groupLabel) parts.push(`  group: ${line2.groupLabel}`);
+  if (line2.billable === false) parts.push("  (scope only \u2014 not billable)");
+  const clauseLines = clauseSummaryLines(parseProductClause(line2.clause));
+  if (clauseLines.length > 0) {
+    parts.push("  scope:");
+    clauseLines.forEach((l4) => parts.push(`    - ${l4}`));
+  }
+  return parts.join("\n");
 }
 
 // src/tools/invoices.ts
@@ -113558,22 +114394,150 @@ var INVOICE_STATUSES = [
   "scheduled",
   "refunded"
 ];
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function textResponse3(text3) {
+  return { content: [{ type: "text", text: text3 }] };
+}
+function tiptapNote(text3) {
+  return {
+    type: "doc",
+    content: [{ type: "paragraph", content: [{ type: "text", text: text3 }] }]
+  };
+}
+var INVOICE_DETAIL_COLUMNS = {
+  id: schema_exports.invoices.id,
+  teamId: schema_exports.invoices.teamId,
+  invoiceNumber: schema_exports.invoices.invoiceNumber,
+  status: schema_exports.invoices.status,
+  customerId: schema_exports.invoices.customerId,
+  customerName: schema_exports.invoices.customerName,
+  amount: schema_exports.invoices.amount,
+  subtotal: schema_exports.invoices.subtotal,
+  vat: schema_exports.invoices.vat,
+  tax: schema_exports.invoices.tax,
+  discount: schema_exports.invoices.discount,
+  currency: schema_exports.invoices.currency,
+  issueDate: schema_exports.invoices.issueDate,
+  dueDate: schema_exports.invoices.dueDate,
+  createdAt: schema_exports.invoices.createdAt,
+  updatedAt: schema_exports.invoices.updatedAt,
+  note: schema_exports.invoices.note,
+  internalNote: schema_exports.invoices.internalNote,
+  lineItems: schema_exports.invoices.lineItems,
+  template: schema_exports.invoices.template,
+  noteDetails: schema_exports.invoices.noteDetails
+};
+var PRODUCT_COLUMNS = {
+  id: schema_exports.invoiceProducts.id,
+  name: schema_exports.invoiceProducts.name,
+  description: schema_exports.invoiceProducts.description,
+  price: schema_exports.invoiceProducts.price,
+  currency: schema_exports.invoiceProducts.currency,
+  unit: schema_exports.invoiceProducts.unit,
+  isConfigurable: schema_exports.invoiceProducts.isConfigurable,
+  options: schema_exports.invoiceProducts.options,
+  billingType: schema_exports.invoiceProducts.billingType,
+  category: schema_exports.invoiceProducts.category,
+  includedItems: schema_exports.invoiceProducts.includedItems,
+  optional: schema_exports.invoiceProducts.optional,
+  tier: schema_exports.invoiceProducts.tier,
+  clause: schema_exports.invoiceProducts.clause,
+  serviceCadence: schema_exports.invoiceProducts.serviceCadence,
+  pricingOptions: schema_exports.invoiceProducts.pricingOptions,
+  defaultPricingOptionId: schema_exports.invoiceProducts.defaultPricingOptionId
+};
+function parseStoredLineItems(value) {
+  return Array.isArray(value) ? value : [];
+}
+async function loadInvoiceByIdentifier(identifier, teamIds) {
+  if (teamIds.length === 0) return null;
+  const byId = UUID_RE.test(identifier);
+  const filters = [inArray(schema_exports.invoices.teamId, teamIds)];
+  filters.push(
+    byId ? eq(schema_exports.invoices.id, identifier) : eq(schema_exports.invoices.invoiceNumber, identifier)
+  );
+  const [row] = await db.select(INVOICE_DETAIL_COLUMNS).from(schema_exports.invoices).where(and(...filters)).limit(1);
+  return row ?? null;
+}
+async function loadInvoiceInTeam(identifier, teamId) {
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  return loadInvoiceByIdentifier(identifier, accessibleTeamIds);
+}
+async function loadProductsInTeam(productIds, teamId) {
+  if (productIds.length === 0) return /* @__PURE__ */ new Map();
+  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
+  const rows = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
+    and(
+      inArray(schema_exports.invoiceProducts.id, productIds),
+      inArray(schema_exports.invoiceProducts.teamId, accessibleTeamIds)
+    )
+  );
+  return new Map(rows.map((r6) => [r6.id, r6]));
+}
+async function resolveInvoiceLineItems(inputs, defaults, teamId) {
+  const productIds = inputs.map((i6) => i6.productId).filter((id) => Boolean(id));
+  const products = await loadProductsInTeam([...new Set(productIds)], teamId);
+  const items = [];
+  for (const input of inputs) {
+    if (input.productId) {
+      const product = products.get(input.productId);
+      if (!product) {
+        return {
+          items: [],
+          error: `Product ${input.productId} not found or not owned by this team.`
+        };
+      }
+      items.push(
+        buildInvoiceLineFromProduct(
+          product,
+          {
+            quantity: input.quantity,
+            customDescription: input.name ?? input.description,
+            customPrice: input.price,
+            pricingOptionId: input.pricingOptionId,
+            prorate: input.prorate,
+            startDate: input.startDate,
+            periodEndDate: input.periodEndDate
+          },
+          defaults
+        )
+      );
+      continue;
+    }
+    const quantity = input.quantity ?? 1;
+    const price = input.price ?? 0;
+    const name21 = input.name?.trim() || input.description?.trim() || "(no description)";
+    const { vat, tax } = lineFinancials(quantity, price, defaults);
+    items.push({ name: name21, quantity, unit: input.unit, price, vat, tax });
+  }
+  return { items };
+}
+function notDraftResponse(invoice) {
+  return textResponse3(
+    `Invoice ${invoice.invoiceNumber ?? invoice.id} has status "${invoice.status}", not "draft". These tools only modify draft invoices \u2014 sent/paid/unpaid/overdue invoices are immutable here.`
+  );
+}
+function formatInvoiceSummary(invoice) {
+  const items = parseStoredLineItems(invoice.lineItems);
+  return `**${invoice.invoiceNumber ?? "(draft, no number)"}** (${invoice.status})
+ID: ${invoice.id}
+Customer: ${invoice.customerName ?? invoice.customerId ?? "(none)"}
+Total: ${invoice.amount ?? "?"} ${invoice.currency ?? ""} (subtotal ${invoice.subtotal ?? "?"}, VAT ${invoice.vat ?? 0})
+Line items: ${items.length}
+Issue: ${invoice.issueDate ? new Date(invoice.issueDate).toLocaleDateString() : "-"} | Due: ${invoice.dueDate ? new Date(invoice.dueDate).toLocaleDateString() : "-"}
+`;
+}
 async function handleGetInvoices(input) {
   const { customerId, status, q: q3, pageSize = 20 } = input;
   if (status && !INVOICE_STATUSES.includes(status)) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: invalid status "${status}". Allowed: ${INVOICE_STATUSES.join(", ")}.`
-        }
-      ]
-    };
+    return textResponse3(
+      `Error: invalid status "${status}". Allowed: ${INVOICE_STATUSES.join(", ")}.`
+    );
   }
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return { content: [{ type: "text", text: "No accessible teams found." }] };
+    return textResponse3("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.invoices.teamId, scope.teamIds)];
   if (customerId) filters.push(eq(schema_exports.invoices.customerId, customerId));
@@ -113600,7 +114564,7 @@ async function handleGetInvoices(input) {
     createdAt: schema_exports.invoices.createdAt
   }).from(schema_exports.invoices).where(and(...filters)).orderBy(desc(schema_exports.invoices.createdAt)).limit(Math.min(pageSize, 100));
   if (rows.length === 0) {
-    return { content: [{ type: "text", text: "No invoices found." }] };
+    return textResponse3("No invoices found.");
   }
   const list = rows.map(
     (inv) => `**${inv.invoiceNumber ?? "(draft, no number)"}**
@@ -113610,29 +114574,251 @@ Customer: ${inv.customerName ?? inv.customerId ?? "(none)"}
 Issue date: ${inv.issueDate ? new Date(inv.issueDate).toLocaleDateString() : "-"} | Due: ${inv.dueDate ? new Date(inv.dueDate).toLocaleDateString() : "-"}
 `
   ).join("\n");
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Found ${rows.length} invoices:
+  return textResponse3(
+    `Found ${rows.length} invoices:
 
 ${list}
-Use \`link-document-to-invoice\` (or \`invoiceId\` on create-document) to attach a deliverables document to one of these invoices.`
-      }
-    ]
-  };
+Use \`get-invoice-by-id\` for line items and linked documents. Use \`link-document-to-invoice\` (or \`invoiceId\` on create-document) to attach deliverables.`
+  );
+}
+async function handleGetInvoiceById(input) {
+  const { invoiceId } = input;
+  if (!invoiceId) return textResponse3("Error: `invoiceId` is required.");
+  const scope = await resolveTeamScope(input.teamId);
+  if (!scope.ok) return scope.response;
+  if (scope.teamIds.length === 0) {
+    return textResponse3("No accessible teams found.");
+  }
+  const invoice = await loadInvoiceByIdentifier(invoiceId, scope.teamIds);
+  if (!invoice) {
+    return textResponse3(
+      `Invoice ${invoiceId} not found or you don't have access to it.`
+    );
+  }
+  const lineItems = parseStoredLineItems(invoice.lineItems);
+  const linkedDocs = await db.select({
+    id: schema_exports.documents.id,
+    title: schema_exports.documents.title,
+    type: schema_exports.documents.type
+  }).from(schema_exports.documents).where(
+    and(
+      eq(schema_exports.documents.invoiceId, invoice.id),
+      isNull(schema_exports.documents.deletedAt)
+    )
+  );
+  const linesText = lineItems.length > 0 ? lineItems.map((line2, i6) => formatLineItemDetail(line2, i6)).join("\n\n") : "(no line items)";
+  const docsText = linkedDocs.length > 0 ? linkedDocs.map((d6) => `- ${d6.title} (${d6.type ?? "document"}) \u2014 ${d6.id}`).join("\n") : "(none)";
+  return textResponse3(
+    `**Invoice ${invoice.invoiceNumber ?? invoice.id}**
+
+ID: ${invoice.id}
+Status: ${invoice.status}
+Customer: ${invoice.customerName ?? invoice.customerId ?? "(none)"}
+Currency: ${invoice.currency ?? "EUR"}
+Issue date: ${invoice.issueDate ? new Date(invoice.issueDate).toLocaleDateString() : "-"}
+Due date: ${invoice.dueDate ? new Date(invoice.dueDate).toLocaleDateString() : "-"}
+Subtotal: ${invoice.subtotal ?? "?"} | VAT: ${invoice.vat ?? 0} | Tax: ${invoice.tax ?? 0} | Total: ${invoice.amount ?? "?"}
+
+**Line items (${lineItems.length})**
+${linesText}
+
+**Linked documents (${linkedDocs.length})**
+${docsText}
+
+` + (invoice.status === "draft" ? "This invoice is a draft \u2014 use `update-invoice-lines` to compact descriptions or `add-product-to-invoice` to add catalog products." : "This invoice is not a draft \u2014 line items are read-only via MCP.")
+  );
+}
+async function handleUpdateInvoice(input) {
+  const { invoiceId } = input;
+  if (!invoiceId) return textResponse3("Error: `invoiceId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const invoice = await loadInvoiceInTeam(invoiceId, resolved.teamId);
+  if (!invoice) {
+    return textResponse3(
+      `Invoice ${invoiceId} not found or not owned by this team.`
+    );
+  }
+  if (invoice.status !== "draft") return notDraftResponse(invoice);
+  const defaults = templateDefaultsFromInvoice(
+    invoice.template,
+    invoice.currency
+  );
+  const updates = {};
+  if (input.title !== void 0) {
+    updates.template = { ...defaults.raw, title: input.title };
+  }
+  if (input.note !== void 0) {
+    updates.noteDetails = input.note ? tiptapNote(input.note) : null;
+  }
+  if (input.internalNote !== void 0) {
+    updates.internalNote = input.internalNote;
+  }
+  if (input.dueDate !== void 0) updates.dueDate = input.dueDate;
+  if (input.issueDate !== void 0) updates.issueDate = input.issueDate;
+  if (input.lineItems !== void 0) {
+    const { items, error: error49 } = await resolveInvoiceLineItems(
+      input.lineItems,
+      defaults,
+      invoice.teamId
+    );
+    if (error49) return textResponse3(`Error: ${error49}`);
+    const totals = computeInvoiceTotals(
+      items,
+      defaults,
+      invoice.discount ?? 0
+    );
+    updates.lineItems = items;
+    updates.subtotal = totals.subtotal;
+    updates.vat = totals.vat;
+    updates.tax = totals.tax;
+    updates.amount = totals.amount;
+  }
+  if (Object.keys(updates).length === 0) {
+    return textResponse3(
+      "No fields to update. Provide at least one of: title, note, internalNote, dueDate, issueDate, lineItems."
+    );
+  }
+  updates.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const [updated] = await db.update(schema_exports.invoices).set(updates).where(eq(schema_exports.invoices.id, invoice.id)).returning(INVOICE_DETAIL_COLUMNS);
+  if (!updated) return textResponse3(`Failed to update invoice ${invoiceId}.`);
+  return textResponse3(`\u2705 **Draft invoice updated**
+
+${formatInvoiceSummary(updated)}`);
+}
+async function handleUpdateInvoiceLines(input) {
+  const { invoiceId, lineItems: patches } = input;
+  if (!invoiceId) return textResponse3("Error: `invoiceId` is required.");
+  if (!patches || patches.length === 0) {
+    return textResponse3("Error: `lineItems` must be a non-empty array.");
+  }
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const invoice = await loadInvoiceInTeam(invoiceId, resolved.teamId);
+  if (!invoice) {
+    return textResponse3(
+      `Invoice ${invoiceId} not found or not owned by this team.`
+    );
+  }
+  if (invoice.status !== "draft") return notDraftResponse(invoice);
+  const defaults = templateDefaultsFromInvoice(
+    invoice.template,
+    invoice.currency
+  );
+  const items = [...parseStoredLineItems(invoice.lineItems)];
+  let updatedCount = 0;
+  for (const patch of patches) {
+    const index2 = patch.index;
+    if (index2 < 0 || index2 >= items.length) {
+      return textResponse3(
+        `Error: line index ${index2} is out of range (invoice has ${items.length} line(s)).`
+      );
+    }
+    const line2 = { ...items[index2] };
+    if (patch.description !== void 0) line2.name = patch.description;
+    if (patch.quantity !== void 0) line2.quantity = patch.quantity;
+    if (patch.unit !== void 0) line2.unit = patch.unit ?? void 0;
+    if (patch.price !== void 0) line2.price = patch.price;
+    const qty = line2.quantity ?? 1;
+    const price = line2.price ?? 0;
+    const { vat, tax } = lineFinancials(qty, price, defaults);
+    line2.vat = vat;
+    line2.tax = tax;
+    items[index2] = line2;
+    updatedCount++;
+  }
+  const totals = computeInvoiceTotals(items, defaults, invoice.discount ?? 0);
+  const [updated] = await db.update(schema_exports.invoices).set({
+    lineItems: items,
+    subtotal: totals.subtotal,
+    vat: totals.vat,
+    tax: totals.tax,
+    amount: totals.amount,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq(schema_exports.invoices.id, invoice.id)).returning(INVOICE_DETAIL_COLUMNS);
+  if (!updated) {
+    return textResponse3(`Failed to update invoice lines for ${invoiceId}.`);
+  }
+  const changedLines = patches.map((p3) => {
+    const line2 = items[p3.index];
+    return `[${p3.index}] ${plainTextFromLineItemName(line2.name)}`;
+  }).join("\n");
+  return textResponse3(
+    `\u2705 **Updated ${updatedCount} line item(s) on draft invoice ${updated.invoiceNumber ?? updated.id}**
+
+${changedLines}
+
+New total: ${updated.amount} ${updated.currency} (subtotal ${updated.subtotal}, VAT ${updated.vat})`
+  );
+}
+async function handleAddProductToInvoice(input) {
+  const { invoiceId, productId } = input;
+  if (!invoiceId) return textResponse3("Error: `invoiceId` is required.");
+  if (!productId) return textResponse3("Error: `productId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const invoice = await loadInvoiceInTeam(invoiceId, resolved.teamId);
+  if (!invoice) {
+    return textResponse3(
+      `Invoice ${invoiceId} not found or not owned by this team.`
+    );
+  }
+  if (invoice.status !== "draft") return notDraftResponse(invoice);
+  const products = await loadProductsInTeam([productId], invoice.teamId);
+  const product = products.get(productId);
+  if (!product) {
+    return textResponse3(
+      `Product ${productId} not found or not owned by this team.`
+    );
+  }
+  const defaults = templateDefaultsFromInvoice(
+    invoice.template,
+    invoice.currency
+  );
+  const newItem = buildInvoiceLineFromProduct(
+    product,
+    {
+      quantity: input.quantity,
+      customDescription: input.customDescription,
+      customPrice: input.customPrice,
+      pricingOptionId: input.pricingOptionId,
+      prorate: input.prorate,
+      startDate: input.startDate,
+      periodEndDate: input.periodEndDate
+    },
+    defaults
+  );
+  const items = [...parseStoredLineItems(invoice.lineItems), newItem];
+  const totals = computeInvoiceTotals(items, defaults, invoice.discount ?? 0);
+  const [updated] = await db.update(schema_exports.invoices).set({
+    lineItems: items,
+    subtotal: totals.subtotal,
+    vat: totals.vat,
+    tax: totals.tax,
+    amount: totals.amount,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq(schema_exports.invoices.id, invoice.id)).returning(INVOICE_DETAIL_COLUMNS);
+  if (!updated) {
+    return textResponse3(`Failed to add product to invoice ${invoiceId}.`);
+  }
+  return textResponse3(
+    `\u2705 **Product added to draft invoice ${updated.invoiceNumber ?? updated.id}**
+
+` + formatLineItemDetail(newItem, items.length - 1) + `
+
+New invoice total: ${updated.amount} ${updated.currency} (subtotal ${updated.subtotal}, VAT ${updated.vat})
+Clause and pricing variant are snapshotted on the line \u2014 later catalog edits won't change this invoice.`
+  );
 }
 async function handleLinkDocumentToInvoice(input) {
   const { documentId, invoiceId } = input;
   if (!documentId) {
-    return {
-      content: [{ type: "text", text: "Error: `documentId` is required." }]
-    };
+    return textResponse3("Error: `documentId` is required.");
   }
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return { content: [{ type: "text", text: "No accessible teams found." }] };
+    return textResponse3("No accessible teams found.");
   }
   const [doc] = await db.select({
     id: schema_exports.documents.id,
@@ -113647,51 +114833,31 @@ async function handleLinkDocumentToInvoice(input) {
     )
   ).limit(1);
   if (!doc) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Document ${documentId} not found or you don't have access to it.`
-        }
-      ]
-    };
+    return textResponse3(
+      `Document ${documentId} not found or you don't have access to it.`
+    );
   }
   if (!invoiceId) {
     await db.update(schema_exports.documents).set({ invoiceId: null, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(schema_exports.documents.id, doc.id));
-    return {
-      content: [
-        {
-          type: "text",
-          text: `\u2705 Document "${doc.title}" (${doc.id}) is unlinked from its invoice.`
-        }
-      ]
-    };
+    return textResponse3(
+      `\u2705 Document "${doc.title}" (${doc.id}) is unlinked from its invoice.`
+    );
   }
   const invoice = await findAccessibleInvoice(invoiceId, [doc.teamId]);
   if (!invoice) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: invoice ${invoiceId} not found in team ${doc.teamId}. Use get-invoices to find a valid invoice id.`
-        }
-      ]
-    };
+    return textResponse3(
+      `Error: invoice ${invoiceId} not found in team ${doc.teamId}. Use get-invoices to find a valid invoice id.`
+    );
   }
   await db.update(schema_exports.documents).set({ invoiceId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(schema_exports.documents.id, doc.id));
-  return {
-    content: [
-      {
-        type: "text",
-        text: `\u2705 **Document linked to invoice!**
+  return textResponse3(
+    `\u2705 **Document linked to invoice!**
 
 Document: ${doc.title} (${doc.id})
 Invoice: ${invoice.invoiceNumber ?? invoice.id} (${invoice.status})
 
 The document can now be selected as a PDF attachment when sending this invoice from the dashboard.`
-      }
-    ]
-  };
+  );
 }
 
 // src/tools/project-cleanup-util.ts
@@ -113817,7 +114983,7 @@ ${description ? `Description: ${description}
     ]
   };
 }
-function textResponse2(text3) {
+function textResponse4(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function memberLabel(m4) {
@@ -113831,7 +114997,7 @@ async function requireTeamOwner2(teamId, userId) {
       eq(schema_exports.usersOnTeam.teamId, teamId)
     )
   ).limit(1);
-  return membership?.role === "owner" ? null : textResponse2(OWNER_REQUIRED);
+  return membership?.role === "owner" ? null : textResponse4(OWNER_REQUIRED);
 }
 async function setProjectMemberAccess(params) {
   const { projectId, teamId, memberIds, createdBy } = params;
@@ -113935,7 +115101,7 @@ async function resolveTeamMember(teamId, opts) {
     if (!match) {
       return {
         ok: false,
-        response: textResponse2(
+        response: textResponse4(
           `User ${opts.userId} is not a member of this team. Call get-project-members to see the team roster.`
         )
       };
@@ -113948,7 +115114,7 @@ async function resolveTeamMember(teamId, opts) {
     if (matches.length === 0) {
       return {
         ok: false,
-        response: textResponse2(
+        response: textResponse4(
           `No team member found with email "${opts.email}". Call get-project-members to see the team roster.`
         )
       };
@@ -113956,7 +115122,7 @@ async function resolveTeamMember(teamId, opts) {
     if (matches.length > 1) {
       return {
         ok: false,
-        response: textResponse2(
+        response: textResponse4(
           `Multiple team members match email "${opts.email}". Pass an explicit userId instead.`
         )
       };
@@ -113965,7 +115131,7 @@ async function resolveTeamMember(teamId, opts) {
   }
   return {
     ok: false,
-    response: textResponse2(
+    response: textResponse4(
       "Provide either a userId or an email to identify the member."
     )
   };
@@ -114014,7 +115180,7 @@ async function handleUpdateProject(input) {
   if (!resolved.ok) return resolved.response;
   const existing = await loadProjectInTeam(id, resolved.teamId);
   if (!existing) {
-    return textResponse2(
+    return textResponse4(
       `Project ${id} not found, or it is not owned by this team.`
     );
   }
@@ -114029,7 +115195,7 @@ async function handleUpdateProject(input) {
       )
     ).limit(1);
     if (dupe) {
-      return textResponse2(
+      return textResponse4(
         `A project named "${input.name}" already exists in this team. Choose a different name.`
       );
     }
@@ -114094,7 +115260,7 @@ async function handleUpdateProject(input) {
     customerName: schema_exports.customers.name
   }).from(schema_exports.projects).leftJoin(schema_exports.customers, eq(schema_exports.projects.customerId, schema_exports.customers.id)).where(eq(schema_exports.projects.id, id)).limit(1);
   if (!updated) {
-    return textResponse2(`Failed to update project ${id}.`);
+    return textResponse4(`Failed to update project ${id}.`);
   }
   const lines = [
     "\u2705 **Project Updated**",
@@ -114112,7 +115278,7 @@ async function handleUpdateProject(input) {
   if (willRename) {
     lines.push("", "Note: tickets for this project were renumbered.");
   }
-  return textResponse2(lines.join("\n"));
+  return textResponse4(lines.join("\n"));
 }
 async function handleGetProjectMembers(input) {
   const { projectId } = input;
@@ -114120,7 +115286,7 @@ async function handleGetProjectMembers(input) {
   if (!resolved.ok) return resolved.response;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse2(
+    return textResponse4(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -114149,7 +115315,7 @@ async function handleGetProjectMembers(input) {
     return `- ${memberLabel(m4)} (userId: ${m4.userId}, role: ${m4.role ?? "member"}) \u2014 ${access}`;
   }).join("\n");
   const note = state2.projectMemberIds.size === 0 ? "No members are explicitly assigned to this project, so every owner and every unrestricted member can see it." : `${state2.projectMemberIds.size} member(s) are explicitly assigned to this project.`;
-  return textResponse2(
+  return textResponse4(
     `**Project members for "${project.name}"** (ID: ${project.id})
 
 ${note}
@@ -114170,7 +115336,7 @@ async function handleSetProjectMembers(input) {
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse2(
+    return textResponse4(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -114208,7 +115374,7 @@ async function handleSetProjectMembers(input) {
 
 \u26A0\uFE0F ${names} previously had no restrictions (could see all projects). They are now restricted to only the projects explicitly assigned to them.`;
   }
-  return textResponse2(
+  return textResponse4(
     `\u2705 **Project members updated**
 
 Members with explicit access to this project:
@@ -114224,7 +115390,7 @@ async function handleAddProjectMember(input) {
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse2(
+    return textResponse4(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -114235,7 +115401,7 @@ async function handleAddProjectMember(input) {
   if (!member2.ok) return member2.response;
   const state2 = await getProjectAccessState(resolved.teamId, projectId);
   if (state2.projectMemberIds.has(member2.member.userId)) {
-    return textResponse2(
+    return textResponse4(
       `${memberLabel(member2.member)} already has explicit access to this project.`
     );
   }
@@ -114250,7 +115416,7 @@ async function handleAddProjectMember(input) {
   if (wasUnrestricted) {
     text3 += "\n\n\u26A0\uFE0F This member previously had no access restrictions (they could see all projects). They are now restricted to ONLY the projects explicitly assigned to them. Grant any other projects they still need with add-project-member, or remove all their assignments to restore full visibility.";
   }
-  return textResponse2(text3);
+  return textResponse4(text3);
 }
 async function handleRemoveProjectMember(input) {
   const ctx = getAuthContext();
@@ -114261,7 +115427,7 @@ async function handleRemoveProjectMember(input) {
   if (ownerError) return ownerError;
   const project = await loadProjectInTeam(projectId, resolved.teamId);
   if (!project) {
-    return textResponse2(
+    return textResponse4(
       `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
@@ -114271,298 +115437,126 @@ async function handleRemoveProjectMember(input) {
   });
   if (!member2.ok) return member2.response;
   const state2 = await getProjectAccessState(resolved.teamId, projectId);
-  if (!state2.projectMemberIds.has(member2.member.userId)) {
-    return textResponse2(
-      `${memberLabel(member2.member)} has no explicit assignment to this project; nothing to remove.`
-    );
-  }
-  await setProjectMemberAccess({
-    projectId,
-    teamId: resolved.teamId,
-    memberIds: [...state2.projectMemberIds].filter(
-      (uid2) => uid2 !== member2.member.userId
-    ),
-    createdBy: ctx.userId
-  });
-  let text3 = `\u2705 Removed ${memberLabel(member2.member)} (userId: ${member2.member.userId}) from the project.`;
-  if ((state2.rowCountByUser.get(member2.member.userId) ?? 0) <= 1) {
-    text3 += "\n\nThis was the member's last project assignment, so their access restrictions were cleared \u2014 they can see all projects in the team again (default behavior).";
-  }
-  return textResponse2(text3);
-}
-async function loadProjectForCleanup(projectId, teamId) {
-  const accessibleTeamIds = await getAccessibleTeamIds(teamId);
-  const [row] = await db.select({
-    id: schema_exports.projects.id,
-    name: schema_exports.projects.name,
-    teamId: schema_exports.projects.teamId,
-    settings: schema_exports.projects.settings
-  }).from(schema_exports.projects).where(eq(schema_exports.projects.id, projectId)).limit(1);
-  if (!row || !row.teamId || !accessibleTeamIds.includes(row.teamId)) {
-    return null;
-  }
-  return { id: row.id, name: row.name, teamId: row.teamId, settings: row.settings };
-}
-async function countProjectDependencies(projectId) {
-  const countRows = (table) => db.select({ c: sql`count(*)::int` }).from(table).where(eq(table.projectId, projectId)).then((r6) => r6[0]?.c ?? 0);
-  const [tickets3, timesheetEvents2, timesheetTemplates2, trips2, tripTemplates2] = await Promise.all([
-    countRows(schema_exports.tickets),
-    countRows(schema_exports.timesheetEvents),
-    countRows(schema_exports.timesheetTemplates),
-    countRows(schema_exports.trips),
-    countRows(schema_exports.tripTemplates)
-  ]);
-  return { tickets: tickets3, timesheetEvents: timesheetEvents2, timesheetTemplates: timesheetTemplates2, trips: trips2, tripTemplates: tripTemplates2 };
-}
-async function handleArchiveProject(input) {
-  const { projectId, reason } = input;
-  if (!projectId) return textResponse2("Error: `projectId` is required.");
-  const resolved = await resolveTeamId(input.teamId);
-  if (!resolved.ok) return resolved.response;
-  const project = await loadProjectForCleanup(projectId, resolved.teamId);
-  if (!project) {
-    return textResponse2(
-      `Project ${projectId} not found, or it is not owned by this team.`
-    );
-  }
-  const state2 = getProjectArchiveState(project.settings);
-  if (state2.archived) {
-    return textResponse2(
-      `Project "${project.name}" (${project.id}) is already archived${state2.archivedAt ? ` (since ${state2.archivedAt})` : ""}.`
-    );
-  }
-  const archivedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const nextSettings = withArchiveSettings(project.settings, archivedAt, reason);
-  await db.update(schema_exports.projects).set({ settings: nextSettings, updatedAt: sql`now()` }).where(eq(schema_exports.projects.id, project.id));
-  return textResponse2(
-    `\u2705 **Project archived**
-
-Project: ${project.name}
-ID: ${project.id}
-Action: archived (soft, reversible)
-Status: archived
-Timestamp: ${archivedAt}
-${reason ? `Reason: ${reason}
-` : ""}
-Archived projects are hidden from get-projects by default (pass status: 'archived' or 'all' to see them). No tickets, hours, or other data were touched.
-
-Note: the archive flag is stored in \`projects.settings.archivedAt\`; the dashboard UI does not yet read it, so the project still appears there.`
-  );
-}
-async function handleDeleteProject(input) {
-  const ctx = getAuthContext();
-  const { projectId, confirmEmptyOnly } = input;
-  if (!projectId) return textResponse2("Error: `projectId` is required.");
-  const resolved = await resolveTeamId(input.teamId);
-  if (!resolved.ok) return resolved.response;
-  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
-  if (ownerError) return ownerError;
-  const project = await loadProjectForCleanup(projectId, resolved.teamId);
-  if (!project) {
-    return textResponse2(
-      `Project ${projectId} not found, or it is not owned by this team.`
-    );
-  }
-  const deps = await countProjectDependencies(project.id);
-  const summary = formatProjectDependencies(deps);
-  if (!isProjectEmpty(deps)) {
-    return textResponse2(
-      `\u{1F6AB} **Delete blocked** \u2014 project "${project.name}" (${project.id}) is not empty.
-
-Dependencies: ${summary}.
-
-A hard delete would orphan these records, so it is not allowed. Use archive-project instead to safely retire this project (reversible, keeps all data).`
-    );
-  }
-  if (confirmEmptyOnly !== true) {
-    return textResponse2(
-      `Project "${project.name}" (${project.id}) has no dependencies and can be safely deleted. This is a permanent hard delete. Re-run delete-project with confirmEmptyOnly: true to proceed (or use archive-project to keep the record).`
-    );
-  }
-  await db.delete(schema_exports.projects).where(eq(schema_exports.projects.id, project.id));
-  return textResponse2(
-    `\u2705 **Project deleted**
-
-Project: ${project.name}
-ID: ${project.id}
-Action: hard delete (empty project)
-Status: deleted
-Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}
-
-The project had no tickets, hours, trips, or templates. Any project-scoped config (member access, tags, slack/github links, team rates) was removed with it.`
-  );
-}
-
-// ../invoice/src/utils/included-items.ts
-function parseIncludedItems(value) {
-  if (value == null) return null;
-  if (!Array.isArray(value)) return null;
-  const items = [];
-  for (const entry of value) {
-    if (typeof entry === "string") {
-      const label = entry.trim();
-      if (label) items.push({ label });
-      continue;
-    }
-    if (entry && typeof entry === "object" && "label" in entry) {
-      const raw = entry;
-      const label = String(raw.label ?? "").trim();
-      if (!label) continue;
-      items.push({
-        label,
-        productId: raw.productId ?? null
-      });
-    }
-  }
-  return items.length > 0 ? items : null;
-}
-function serializeIncludedItems(items) {
-  if (items == null) return null;
-  const cleaned = items.map((item) => ({
-    label: item.label.trim(),
-    ...item.productId ? { productId: item.productId } : {}
-  })).filter((item) => item.label.length > 0);
-  return cleaned.length > 0 ? cleaned : null;
-}
-function includedItemLabels(items) {
-  const parsed = items ? serializeIncludedItems(items) : null;
-  if (!parsed?.length) return null;
-  return parsed.map((item) => item.label);
-}
-
-// ../invoice/src/utils/product-clause.ts
-function trimToNull(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function parseStringList(value) {
-  if (!Array.isArray(value)) return [];
-  const out = [];
-  for (const entry of value) {
-    const label = trimToNull(entry);
-    if (label) out.push(label);
-  }
-  return out;
-}
-function parseLimits(value) {
-  if (!value || typeof value !== "object") return null;
-  const raw = value;
-  const hoursRaw = raw.includedHoursPerMonth;
-  let includedHoursPerMonth = null;
-  if (typeof hoursRaw === "number" && Number.isFinite(hoursRaw)) {
-    includedHoursPerMonth = hoursRaw;
-  } else if (typeof hoursRaw === "string" && hoursRaw.trim() !== "") {
-    const parsed = Number(hoursRaw);
-    if (Number.isFinite(parsed)) includedHoursPerMonth = parsed;
-  }
-  const rollover = typeof raw.rollover === "boolean" ? raw.rollover : null;
-  const limits = {
-    includedHoursPerMonth,
-    rollover,
-    minimumBillingUnitExtraWork: trimToNull(raw.minimumBillingUnitExtraWork),
-    responseTime: trimToNull(raw.responseTime),
-    supportLevel: trimToNull(raw.supportLevel)
-  };
-  return isLimitsEmpty(limits) ? null : limits;
-}
-function isLimitsEmpty(limits) {
-  if (!limits) return true;
-  return limits.includedHoursPerMonth == null && limits.rollover == null && !limits.minimumBillingUnitExtraWork && !limits.responseTime && !limits.supportLevel;
-}
-function parseProductClause(value) {
-  if (value == null) return null;
-  if (typeof value !== "object" || Array.isArray(value)) return null;
-  const raw = value;
-  const clause = {
-    commercialDescription: trimToNull(raw.commercialDescription),
-    includedScope: parseStringList(raw.includedScope),
-    excludedScope: parseStringList(raw.excludedScope),
-    limits: parseLimits(raw.limits),
-    customerValue: trimToNull(raw.customerValue),
-    extraWorkConditions: trimToNull(raw.extraWorkConditions)
-  };
-  return isClauseEmpty(clause) ? null : clause;
-}
-function isClauseEmpty(clause) {
-  if (!clause) return true;
-  return !clause.commercialDescription && (clause.includedScope?.length ?? 0) === 0 && (clause.excludedScope?.length ?? 0) === 0 && isLimitsEmpty(clause.limits) && !clause.customerValue && !clause.extraWorkConditions;
-}
-function serializeProductClause(clause) {
-  if (clause == null) return null;
-  const parsed = parseProductClause(clause);
-  if (!parsed) return null;
-  const out = {};
-  if (parsed.commercialDescription) {
-    out.commercialDescription = parsed.commercialDescription;
-  }
-  if (parsed.includedScope && parsed.includedScope.length > 0) {
-    out.includedScope = parsed.includedScope;
-  }
-  if (parsed.excludedScope && parsed.excludedScope.length > 0) {
-    out.excludedScope = parsed.excludedScope;
-  }
-  if (!isLimitsEmpty(parsed.limits)) {
-    const limits = parsed.limits;
-    const cleanedLimits = {};
-    if (limits.includedHoursPerMonth != null) {
-      cleanedLimits.includedHoursPerMonth = limits.includedHoursPerMonth;
-    }
-    if (limits.rollover != null) cleanedLimits.rollover = limits.rollover;
-    if (limits.minimumBillingUnitExtraWork) {
-      cleanedLimits.minimumBillingUnitExtraWork = limits.minimumBillingUnitExtraWork;
-    }
-    if (limits.responseTime) cleanedLimits.responseTime = limits.responseTime;
-    if (limits.supportLevel) cleanedLimits.supportLevel = limits.supportLevel;
-    out.limits = cleanedLimits;
+  if (!state2.projectMemberIds.has(member2.member.userId)) {
+    return textResponse4(
+      `${memberLabel(member2.member)} has no explicit assignment to this project; nothing to remove.`
+    );
   }
-  if (parsed.customerValue) out.customerValue = parsed.customerValue;
-  if (parsed.extraWorkConditions) {
-    out.extraWorkConditions = parsed.extraWorkConditions;
+  await setProjectMemberAccess({
+    projectId,
+    teamId: resolved.teamId,
+    memberIds: [...state2.projectMemberIds].filter(
+      (uid2) => uid2 !== member2.member.userId
+    ),
+    createdBy: ctx.userId
+  });
+  let text3 = `\u2705 Removed ${memberLabel(member2.member)} (userId: ${member2.member.userId}) from the project.`;
+  if ((state2.rowCountByUser.get(member2.member.userId) ?? 0) <= 1) {
+    text3 += "\n\nThis was the member's last project assignment, so their access restrictions were cleared \u2014 they can see all projects in the team again (default behavior).";
   }
-  return Object.keys(out).length > 0 ? out : null;
+  return textResponse4(text3);
 }
-function clauseLimitLines(limits) {
-  if (isLimitsEmpty(limits) || !limits) return [];
-  const lines = [];
-  if (limits.includedHoursPerMonth != null) {
-    lines.push(`Inbegrepen uren per maand: ${limits.includedHoursPerMonth}`);
+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;
   }
-  if (limits.rollover != null) {
-    lines.push(
-      limits.rollover ? "Niet-gebruikte uren schuiven door naar de volgende maand" : "Niet-gebruikte uren vervallen aan het einde van de maand"
+  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 textResponse4("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 textResponse4(
+      `Project ${projectId} not found, or it is not owned by this team.`
     );
   }
-  if (limits.minimumBillingUnitExtraWork) {
-    lines.push(
-      `Minimale facturatie-eenheid meerwerk: ${limits.minimumBillingUnitExtraWork}`
+  const state2 = getProjectArchiveState(project.settings);
+  if (state2.archived) {
+    return textResponse4(
+      `Project "${project.name}" (${project.id}) is already archived${state2.archivedAt ? ` (since ${state2.archivedAt})` : ""}.`
     );
   }
-  if (limits.supportLevel) lines.push(`Supportniveau: ${limits.supportLevel}`);
-  if (limits.responseTime) lines.push(`Responstijd: ${limits.responseTime}`);
-  return lines;
+  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 textResponse4(
+    `\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.`
+  );
 }
-function clauseSummaryLines(clause) {
-  const parsed = parseProductClause(clause);
-  if (!parsed) return [];
-  const lines = [];
-  if (parsed.commercialDescription) {
-    lines.push(parsed.commercialDescription);
-  }
-  if (parsed.includedScope?.length) {
-    lines.push(`Inbegrepen: ${parsed.includedScope.join("; ")}`);
-  }
-  if (parsed.excludedScope?.length) {
-    lines.push(`Niet inbegrepen: ${parsed.excludedScope.join("; ")}`);
+async function handleDeleteProject(input) {
+  const ctx = getAuthContext();
+  const { projectId, confirmEmptyOnly } = input;
+  if (!projectId) return textResponse4("Error: `projectId` is required.");
+  const resolved = await resolveTeamId(input.teamId);
+  if (!resolved.ok) return resolved.response;
+  const ownerError = await requireTeamOwner2(resolved.teamId, ctx.userId);
+  if (ownerError) return ownerError;
+  const project = await loadProjectForCleanup(projectId, resolved.teamId);
+  if (!project) {
+    return textResponse4(
+      `Project ${projectId} not found, or it is not owned by this team.`
+    );
   }
-  lines.push(...clauseLimitLines(parsed.limits));
-  if (parsed.customerValue) {
-    lines.push(`Klantwaarde: ${parsed.customerValue}`);
+  const deps = await countProjectDependencies(project.id);
+  const summary = formatProjectDependencies(deps);
+  if (!isProjectEmpty(deps)) {
+    return textResponse4(
+      `\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 (parsed.extraWorkConditions) {
-    lines.push(`Meerwerk: ${parsed.extraWorkConditions}`);
+  if (confirmEmptyOnly !== true) {
+    return textResponse4(
+      `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).`
+    );
   }
-  return lines;
+  await db.delete(schema_exports.projects).where(eq(schema_exports.projects.id, project.id));
+  return textResponse4(
+    `\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
@@ -114583,7 +115577,7 @@ var TIERS = [
   "silver",
   "gold"
 ];
-var PRODUCT_COLUMNS = {
+var PRODUCT_COLUMNS2 = {
   id: schema_exports.invoiceProducts.id,
   teamId: schema_exports.invoiceProducts.teamId,
   name: schema_exports.invoiceProducts.name,
@@ -114605,7 +115599,7 @@ var PRODUCT_COLUMNS = {
   createdAt: schema_exports.invoiceProducts.createdAt,
   updatedAt: schema_exports.invoiceProducts.updatedAt
 };
-function textResponse3(text3) {
+function textResponse5(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function formatPrice(p3) {
@@ -114651,14 +115645,14 @@ async function handleGetProducts(input) {
   const { q: q3, currency, pageSize = 20 } = input;
   const status = input.status ?? "active";
   if (!PRODUCT_STATUSES.includes(status)) {
-    return textResponse3(
+    return textResponse5(
       `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 textResponse3("No accessible teams found.");
+    return textResponse5("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.invoiceProducts.teamId, scope.teamIds)];
   if (status === "active") {
@@ -114675,17 +115669,17 @@ async function handleGetProducts(input) {
       )
     );
   }
-  const rows = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(and(...filters)).orderBy(
+  const rows = await db.select(PRODUCT_COLUMNS2).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 textResponse3(
+    return textResponse5(
       `No products found${status !== "all" ? ` (status: ${status})` : ""}.`
     );
   }
-  return textResponse3(
+  return textResponse5(
     `Found ${rows.length} product(s):
 
 ${rows.map(formatProduct).join("\n")}`
@@ -114693,28 +115687,28 @@ ${rows.map(formatProduct).join("\n")}`
 }
 async function handleGetProductById(input) {
   const { productId } = input;
-  if (!productId) return textResponse3("Error: `productId` is required.");
+  if (!productId) return textResponse5("Error: `productId` is required.");
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse3("No accessible teams found.");
+    return textResponse5("No accessible teams found.");
   }
-  const [row] = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
+  const [row] = await db.select(PRODUCT_COLUMNS2).from(schema_exports.invoiceProducts).where(
     and(
       eq(schema_exports.invoiceProducts.id, productId),
       inArray(schema_exports.invoiceProducts.teamId, scope.teamIds)
     )
   ).limit(1);
   if (!row) {
-    return textResponse3(
+    return textResponse5(
       `Product ${productId} not found or you don't have access to it.`
     );
   }
-  return textResponse3(formatProduct(row));
+  return textResponse5(formatProduct(row));
 }
 async function loadProductInTeam(productId, teamId) {
   const accessibleTeamIds = await getAccessibleTeamIds(teamId);
-  const [row] = await db.select(PRODUCT_COLUMNS).from(schema_exports.invoiceProducts).where(
+  const [row] = await db.select(PRODUCT_COLUMNS2).from(schema_exports.invoiceProducts).where(
     and(
       eq(schema_exports.invoiceProducts.id, productId),
       inArray(schema_exports.invoiceProducts.teamId, accessibleTeamIds)
@@ -114725,10 +115719,10 @@ async function loadProductInTeam(productId, teamId) {
 async function handleCreateProduct(input) {
   const { name: name21, description, price, currency, unit } = input;
   if (!name21 || name21.trim().length === 0) {
-    return textResponse3("Error: `name` is required.");
+    return textResponse5("Error: `name` is required.");
   }
   const enumError = validateEnum("billingType", input.billingType, BILLING_TYPES) ?? validateEnum("category", input.category, CATEGORIES) ?? validateEnum("tier", input.tier, TIERS);
-  if (enumError) return textResponse3(enumError);
+  if (enumError) return textResponse5(enumError);
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const [created] = await db.insert(schema_exports.invoiceProducts).values({
@@ -114747,9 +115741,9 @@ async function handleCreateProduct(input) {
     clause: serializeProductClause(input.clause) ?? null,
     isActive: true,
     lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).returning(PRODUCT_COLUMNS);
-  if (!created) return textResponse3("Failed to create product.");
-  return textResponse3(
+  }).returning(PRODUCT_COLUMNS2);
+  if (!created) return textResponse5("Failed to create product.");
+  return textResponse5(
     `\u2705 **Product created**
 
 ${formatProduct(created)}`
@@ -114757,21 +115751,21 @@ ${formatProduct(created)}`
 }
 async function handleUpdateProduct(input) {
   const { productId } = input;
-  if (!productId) return textResponse3("Error: `productId` is required.");
+  if (!productId) return textResponse5("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 textResponse3(
+    return textResponse5(
       `Product ${productId} not found, or it is not owned by this team.`
     );
   }
   const enumError = validateEnum("billingType", input.billingType, BILLING_TYPES) ?? validateEnum("category", input.category, CATEGORIES) ?? validateEnum("tier", input.tier, TIERS);
-  if (enumError) return textResponse3(enumError);
+  if (enumError) return textResponse5(enumError);
   const updates = {};
   if (input.name !== void 0) {
     if (!input.name || input.name.trim().length === 0) {
-      return textResponse3("Error: `name` cannot be empty.");
+      return textResponse5("Error: `name` cannot be empty.");
     }
     updates.name = input.name.trim();
   }
@@ -114792,14 +115786,14 @@ async function handleUpdateProduct(input) {
     updates.clause = serializeProductClause(input.clause);
   }
   if (Object.keys(updates).length === 0) {
-    return textResponse3(
+    return textResponse5(
       "No fields to update. Provide at least one of: name, description, price, currency, unit, isActive, billingType, category, includedItems, optional, tier, sortOrder, clause."
     );
   }
   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 textResponse3(`Failed to update product ${productId}.`);
-  return textResponse3(
+  const [updated] = await db.update(schema_exports.invoiceProducts).set(updates).where(eq(schema_exports.invoiceProducts.id, existing.id)).returning(PRODUCT_COLUMNS2);
+  if (!updated) return textResponse5(`Failed to update product ${productId}.`);
+  return textResponse5(
     `\u2705 **Product updated**
 
 ${formatProduct(updated)}
@@ -114808,23 +115802,23 @@ Note: this only affects future invoices/quotes. Existing documents keep their li
 }
 async function handleArchiveProduct(input) {
   const { productId, reason } = input;
-  if (!productId) return textResponse3("Error: `productId` is required.");
+  if (!productId) return textResponse5("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 textResponse3(
+    return textResponse5(
       `Product ${productId} not found, or it is not owned by this team.`
     );
   }
   if (!existing.isActive) {
-    return textResponse3(
+    return textResponse5(
       `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 textResponse3(`Failed to archive product ${productId}.`);
-  return textResponse3(
+  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_COLUMNS2);
+  if (!archived) return textResponse5(`Failed to archive product ${productId}.`);
+  return textResponse5(
     `\u2705 **Product archived** (hidden from new invoices/quotes; existing documents are untouched).
 
 ${formatProduct(archived)}${reason ? `Reason: ${reason}
@@ -114833,28 +115827,25 @@ ${formatProduct(archived)}${reason ? `Reason: ${reason}
 }
 
 // src/tools/quote-line-util.ts
-function round2(n3) {
+function round22(n3) {
   return Math.round(n3 * 100) / 100;
 }
-function lineFinancials(quantity, price, defaults) {
+function lineFinancials2(quantity, price, defaults) {
   const lineTotal = quantity * price;
   return {
-    vat: defaults.includeVat ? round2(lineTotal * (defaults.vatRate / 100)) : void 0,
-    tax: defaults.includeTax ? round2(lineTotal * (defaults.taxRate / 100)) : void 0
+    vat: defaults.includeVat ? round22(lineTotal * (defaults.vatRate / 100)) : void 0,
+    tax: defaults.includeTax ? round22(lineTotal * (defaults.taxRate / 100)) : void 0
   };
 }
 function computeTotals(items, defaults) {
-  const subtotal = items.reduce(
-    (sum, i6) => sum + (i6.quantity || 0) * (i6.price || 0),
-    0
-  );
+  const subtotal = items.reduce((sum, i6) => sum + billableLineTotal(i6), 0);
   const vat = defaults.includeVat ? subtotal * (defaults.vatRate / 100) : 0;
   const tax = defaults.includeTax ? subtotal * (defaults.taxRate / 100) : 0;
   return {
-    subtotal: round2(subtotal),
-    vat: round2(vat),
-    tax: round2(tax),
-    amount: round2(subtotal + vat + tax)
+    subtotal: round22(subtotal),
+    vat: round22(vat),
+    tax: round22(tax),
+    amount: round22(subtotal + vat + tax)
   };
 }
 function snapshotFromProduct(product, defaults, now2 = () => (/* @__PURE__ */ new Date()).toISOString()) {
@@ -114884,7 +115875,7 @@ function snapshotFromProduct(product, defaults, now2 = () => (/* @__PURE__ */ ne
 function lineItemFromProduct(product, opts, defaults, now2 = () => (/* @__PURE__ */ new Date()).toISOString()) {
   const quantity = opts.quantity ?? 1;
   const price = opts.customPrice ?? product.price ?? 0;
-  const { vat, tax } = lineFinancials(quantity, price, defaults);
+  const { vat, tax } = lineFinancials2(quantity, price, defaults);
   return {
     name: opts.customDescription || product.name,
     quantity,
@@ -114924,7 +115915,7 @@ var QUOTE_STATUSES = [
   "expired"
 ];
 var SAFE_DRAFT_STATUSES = /* @__PURE__ */ new Set(["draft"]);
-function textResponse4(text3) {
+function textResponse6(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 async function loadTemplateDefaults(teamId) {
@@ -114990,7 +115981,7 @@ async function nextQuotationNumber(teamId) {
   if (!value) throw new Error("Failed to fetch next quotation number");
   return value;
 }
-async function loadProductsInTeam(productIds, teamId) {
+async function loadProductsInTeam2(productIds, teamId) {
   if (productIds.length === 0) return /* @__PURE__ */ new Map();
   const accessibleTeamIds = await getAccessibleTeamIds(teamId);
   const rows = await db.select({
@@ -115018,7 +116009,7 @@ async function loadProductsInTeam(productIds, teamId) {
 }
 async function resolveLineItems(inputs, defaults, teamId) {
   const productIds = inputs.map((i6) => i6.productId).filter((id) => Boolean(id));
-  const products = await loadProductsInTeam([...new Set(productIds)], teamId);
+  const products = await loadProductsInTeam2([...new Set(productIds)], teamId);
   const items = [];
   for (const input of inputs) {
     if (input.productId) {
@@ -115044,7 +116035,7 @@ async function resolveLineItems(inputs, defaults, teamId) {
     }
     const quantity = input.quantity ?? 1;
     const price = input.price ?? 0;
-    const { vat, tax } = lineFinancials(quantity, price, defaults);
+    const { vat, tax } = lineFinancials2(quantity, price, defaults);
     items.push({
       name: input.name?.trim() || "(no description)",
       quantity,
@@ -115083,7 +116074,7 @@ ${q3.validUntil ? `Valid until: ${new Date(q3.validUntil).toLocaleDateString()}
 ` : ""}Created: ${new Date(q3.createdAt).toLocaleDateString()}
 `;
 }
-function tiptapNote(text3) {
+function tiptapNote2(text3) {
   return {
     type: "doc",
     content: [{ type: "paragraph", content: [{ type: "text", text: text3 }] }]
@@ -115092,14 +116083,14 @@ function tiptapNote(text3) {
 async function handleGetQuotes(input) {
   const { customerId, status, q: q3, pageSize = 20 } = input;
   if (status && !QUOTE_STATUSES.includes(status)) {
-    return textResponse4(
+    return textResponse6(
       `Error: invalid status "${status}". Allowed: ${QUOTE_STATUSES.join(", ")}.`
     );
   }
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse4("No accessible teams found.");
+    return textResponse6("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.quotations.teamId, scope.teamIds)];
   if (customerId) filters.push(eq(schema_exports.quotations.customerId, customerId));
@@ -115114,10 +116105,10 @@ async function handleGetQuotes(input) {
   }
   const rows = await db.select(QUOTE_COLUMNS).from(schema_exports.quotations).where(and(...filters)).orderBy(desc(schema_exports.quotations.createdAt)).limit(Math.min(pageSize, 100));
   if (rows.length === 0) {
-    return textResponse4("No quotes found.");
+    return textResponse6("No quotes found.");
   }
   const note = input.projectId ? "\nNote: `projectId` was ignored \u2014 quotations are not linked to projects." : "";
-  return textResponse4(
+  return textResponse6(
     `Found ${rows.length} quote(s):
 
 ${rows.map(formatQuote).join("\n")}${note}`
@@ -115125,10 +116116,10 @@ ${rows.map(formatQuote).join("\n")}${note}`
 }
 async function handleCreateQuote(input) {
   const { customerId } = input;
-  if (!customerId) return textResponse4("Error: `customerId` is required.");
+  if (!customerId) return textResponse6("Error: `customerId` is required.");
   const status = input.status ?? "draft";
   if (!SAFE_DRAFT_STATUSES.has(status)) {
-    return textResponse4(
+    return textResponse6(
       `Error: this tool only creates draft quotes. Requested status "${status}" is not allowed. Sending/accepting a quote is a manual dashboard action.`
     );
   }
@@ -115151,7 +116142,7 @@ async function handleCreateQuote(input) {
     )
   ).limit(1);
   if (!customer) {
-    return textResponse4(
+    return textResponse6(
       `Customer ${customerId} not found or not owned by this team.`
     );
   }
@@ -115161,7 +116152,7 @@ async function handleCreateQuote(input) {
     defaults,
     teamId
   );
-  if (error49) return textResponse4(`Error: ${error49}`);
+  if (error49) return textResponse6(`Error: ${error49}`);
   const totals = computeTotals(items, defaults);
   const quotationNumber = await nextQuotationNumber(teamId);
   const template = buildQuoteTemplate(defaults, input.title);
@@ -115212,7 +116203,7 @@ async function handleCreateQuote(input) {
     customerDetails,
     fromDetails: defaults.fromDetails ?? null,
     paymentDetails: defaults.paymentDetails ?? null,
-    noteDetails: input.description ? tiptapNote(input.description) : null,
+    noteDetails: input.description ? tiptapNote2(input.description) : null,
     issueDate: (/* @__PURE__ */ new Date()).toISOString(),
     validUntil: input.validUntil ?? null,
     lineItems: items,
@@ -115221,8 +116212,8 @@ async function handleCreateQuote(input) {
     tax: totals.tax,
     amount: totals.amount
   }).returning(QUOTE_COLUMNS);
-  if (!created) return textResponse4("Failed to create quote.");
-  return textResponse4(
+  if (!created) return textResponse6("Failed to create quote.");
+  return textResponse6(
     `\u2705 **Draft quote created**
 
 ${formatQuote(created)}
@@ -115239,16 +116230,16 @@ async function loadQuoteInTeam(id, teamId) {
   ).limit(1);
   return row ?? null;
 }
-function notDraftResponse(quote) {
-  return textResponse4(
+function notDraftResponse2(quote) {
+  return textResponse6(
     `Quote ${quote.quotationNumber ?? quote.id} has status "${quote.status}", not "draft". These tools only modify draft quotes \u2014 sent/accepted/rejected/expired quotes are immutable here so their product snapshots stay reproducible.`
   );
 }
 async function handleUpdateQuote(input) {
   const { id } = input;
-  if (!id) return textResponse4("Error: `id` is required.");
+  if (!id) return textResponse6("Error: `id` is required.");
   if (input.status !== void 0 && !SAFE_DRAFT_STATUSES.has(input.status)) {
-    return textResponse4(
+    return textResponse6(
       `Error: status can only stay within {${[...SAFE_DRAFT_STATUSES].join(", ")}}. "${input.status}" (send/accept/reject/expire) must be done manually from the dashboard.`
     );
   }
@@ -115256,16 +116247,16 @@ async function handleUpdateQuote(input) {
   if (!resolved.ok) return resolved.response;
   const quote = await loadQuoteInTeam(id, resolved.teamId);
   if (!quote) {
-    return textResponse4(`Quote ${id} not found or not owned by this team.`);
+    return textResponse6(`Quote ${id} not found or not owned by this team.`);
   }
-  if (quote.status !== "draft") return notDraftResponse(quote);
+  if (quote.status !== "draft") return notDraftResponse2(quote);
   const defaults = templateDefaultsFromStored(quote.template, quote.currency);
   const updates = {};
   if (input.title !== void 0) {
     updates.template = buildQuoteTemplate(defaults, input.title);
   }
   if (input.description !== void 0) {
-    updates.noteDetails = input.description ? tiptapNote(input.description) : null;
+    updates.noteDetails = input.description ? tiptapNote2(input.description) : null;
   }
   if (input.validUntil !== void 0) {
     updates.validUntil = input.validUntil;
@@ -115276,7 +116267,7 @@ async function handleUpdateQuote(input) {
       defaults,
       quote.teamId
     );
-    if (error49) return textResponse4(`Error: ${error49}`);
+    if (error49) return textResponse6(`Error: ${error49}`);
     const totals = computeTotals(items, defaults);
     updates.lineItems = items;
     updates.subtotal = totals.subtotal;
@@ -115285,32 +116276,32 @@ async function handleUpdateQuote(input) {
     updates.amount = totals.amount;
   }
   if (Object.keys(updates).length === 0) {
-    return textResponse4(
+    return textResponse6(
       "No fields to update. Provide at least one of: title, description, validUntil, lineItems."
     );
   }
   updates.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const [updated] = await db.update(schema_exports.quotations).set(updates).where(eq(schema_exports.quotations.id, quote.id)).returning(QUOTE_COLUMNS);
-  if (!updated) return textResponse4(`Failed to update quote ${id}.`);
-  return textResponse4(`\u2705 **Draft quote updated**
+  if (!updated) return textResponse6(`Failed to update quote ${id}.`);
+  return textResponse6(`\u2705 **Draft quote updated**
 
 ${formatQuote(updated)}`);
 }
 async function handleAddProductToQuote(input) {
   const { quoteId, productId } = input;
-  if (!quoteId) return textResponse4("Error: `quoteId` is required.");
-  if (!productId) return textResponse4("Error: `productId` is required.");
+  if (!quoteId) return textResponse6("Error: `quoteId` is required.");
+  if (!productId) return textResponse6("Error: `productId` is required.");
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const quote = await loadQuoteInTeam(quoteId, resolved.teamId);
   if (!quote) {
-    return textResponse4(`Quote ${quoteId} not found or not owned by this team.`);
+    return textResponse6(`Quote ${quoteId} not found or not owned by this team.`);
   }
-  if (quote.status !== "draft") return notDraftResponse(quote);
-  const products = await loadProductsInTeam([productId], quote.teamId);
+  if (quote.status !== "draft") return notDraftResponse2(quote);
+  const products = await loadProductsInTeam2([productId], quote.teamId);
   const product = products.get(productId);
   if (!product) {
-    return textResponse4(
+    return textResponse6(
       `Product ${productId} not found or not owned by this team.`
     );
   }
@@ -115336,7 +116327,7 @@ async function handleAddProductToQuote(input) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   }).where(eq(schema_exports.quotations.id, quote.id)).returning(QUOTE_COLUMNS);
   if (!updated) {
-    return textResponse4(`Failed to add product to quote ${quoteId}.`);
+    return textResponse6(`Failed to add product to quote ${quoteId}.`);
   }
   await db.update(schema_exports.invoiceProducts).set({
     usageCount: sql`${schema_exports.invoiceProducts.usageCount} + 1`,
@@ -115352,7 +116343,7 @@ async function handleAddProductToQuote(input) {
   if (meta5.includedItems && meta5.includedItems.length > 0) {
     metaParts.push(`included=[${meta5.includedItems.join(", ")}]`);
   }
-  return textResponse4(
+  return textResponse6(
     `\u2705 **Product added to draft quote ${updated.quotationNumber ?? updated.id}**
 
 Line item: ${newItem.name} \xD7 ${newItem.quantity}${newItem.unit ? ` ${newItem.unit}` : ""} @ ${newItem.price} ${snap.currency}
@@ -121087,7 +122078,7 @@ function formatDeleteAttachmentRefusal(reason, context2) {
 }
 
 // src/tools/ticket-attachments.ts
-function textResponse5(text3) {
+function textResponse7(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 async function findAttachment(attachmentId) {
@@ -121160,7 +122151,7 @@ ${url3}`
 async function handleUploadTicketAttachment(input) {
   const ctx = getAuthContext() ?? authContext;
   if (!ctx) {
-    return textResponse5("Error: Not authenticated.");
+    return textResponse7("Error: Not authenticated.");
   }
   const access = await loadAccessibleTicket(input.teamId, input.ticketId);
   if (!access.ok) return access.response;
@@ -121176,12 +122167,12 @@ async function handleUploadTicketAttachment(input) {
     userId: ctx.userId
   });
   if (!resolved.ok) {
-    return textResponse5(resolved.message);
+    return textResponse7(resolved.message);
   }
   const { buffer: buffer2, fileName, mimeType, stagingStorageKey } = resolved;
   const validationError = validateAttachmentBuffer(buffer2, mimeType);
   if (validationError) {
-    return textResponse5(validationError.message);
+    return textResponse7(validationError.message);
   }
   const storageKey = `${ticket.teamId}/tickets/${ticket.id}/${Date.now()}_${fileName}`;
   try {
@@ -121192,7 +122183,7 @@ async function handleUploadTicketAttachment(input) {
       options: { contentType: mimeType, upsert: true }
     });
   } catch (error49) {
-    return textResponse5(
+    return textResponse7(
       `Upload failed: ${error49 instanceof Error ? error49.message : String(error49)}`
     );
   }
@@ -121221,7 +122212,7 @@ async function handleUploadTicketAttachment(input) {
     url3 = signed.url;
   } catch {
   }
-  return textResponse5(
+  return textResponse7(
     `\u{1F4CE} **Attached to ${ticket.ticketNumber}**
 File: ${fileName}
 Type: ${mimeType}
@@ -121235,18 +122226,18 @@ ${url3}` : "")
 async function handleDeleteTicketAttachment(input) {
   const ctx = getAuthContext() ?? authContext;
   if (!ctx) {
-    return textResponse5("Error: Not authenticated.");
+    return textResponse7("Error: Not authenticated.");
   }
   const inputError = validateDeleteAttachmentInput(input.attachmentId);
   if (inputError) {
-    return textResponse5(formatDeleteAttachmentRefusal(inputError, { ticketNumber: input.ticketId }));
+    return textResponse7(formatDeleteAttachmentRefusal(inputError, { ticketNumber: input.ticketId }));
   }
   const access = await loadAccessibleTicket(input.teamId, input.ticketId);
   if (!access.ok) return access.response;
   const ticket = access.ticket;
   const attachment = await findAttachment(input.attachmentId);
   if (!attachment) {
-    return textResponse5(
+    return textResponse7(
       formatDeleteAttachmentRefusal("attachment_not_found", {
         attachmentId: input.attachmentId,
         ticketNumber: ticket.ticketNumber
@@ -121254,7 +122245,7 @@ async function handleDeleteTicketAttachment(input) {
     );
   }
   if (!validateAttachmentBelongsToTicket(attachment.ticketId, ticket.id)) {
-    return textResponse5(
+    return textResponse7(
       formatDeleteAttachmentRefusal("wrong_ticket", {
         attachmentId: input.attachmentId,
         ticketNumber: ticket.ticketNumber,
@@ -121266,7 +122257,7 @@ async function handleDeleteTicketAttachment(input) {
   const table = attachment.source === "ticket" ? schema_exports.ticketAttachments : schema_exports.ticketCommentAttachments;
   const [deletedRow] = await db.delete(table).where(eq(table.id, input.attachmentId)).returning({ id: table.id });
   if (!deletedRow) {
-    return textResponse5(
+    return textResponse7(
       `Failed to delete attachment ${input.attachmentId}. It may have been removed already.`
     );
   }
@@ -121296,7 +122287,7 @@ async function handleDeleteTicketAttachment(input) {
     fileName: attachment.fileName,
     source: attachment.source
   });
-  return textResponse5(JSON.stringify(result, null, 2));
+  return textResponse7(JSON.stringify(result, null, 2));
 }
 
 // src/tools/tiptap-text.ts
@@ -121713,7 +122704,7 @@ function formatTagUsage(usage) {
 }
 
 // src/tools/tag-management.ts
-function textResponse6(text3) {
+function textResponse8(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 var TAG_COLUMNS = {
@@ -121754,24 +122745,24 @@ function scopeFilter(projectId) {
   return projectId === null ? isNull(schema_exports.tags.projectId) : eq(schema_exports.tags.projectId, projectId);
 }
 async function handleUpdateTag(input) {
-  if (!input.tagId) return textResponse6("Error: `tagId` is required.");
+  if (!input.tagId) return textResponse8("Error: `tagId` is required.");
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const existing = await loadTagInTeam(input.tagId, resolved.teamId);
   if (!existing) {
-    return textResponse6(
+    return textResponse8(
       `Tag ${input.tagId} not found, or it is not owned by this team.`
     );
   }
   const renaming = input.name !== void 0;
   const rescoping = input.projectId !== void 0;
   if (!renaming && !rescoping) {
-    return textResponse6(
+    return textResponse8(
       "No changes requested. Provide `name` to rename and/or `projectId` (string, or null for a general tag) to change scope."
     );
   }
   if (renaming && !isValidTagName(input.name)) {
-    return textResponse6("Error: `name` cannot be empty.");
+    return textResponse8("Error: `name` cannot be empty.");
   }
   const nextName = renaming ? input.name.trim() : existing.name;
   const nextProjectId = rescoping ? input.projectId ?? null : existing.projectId;
@@ -121784,13 +122775,13 @@ async function handleUpdateTag(input) {
     )
   ).limit(1);
   if (collision) {
-    return textResponse6(
+    return textResponse8(
       `\u274C Cannot update: another tag already uses the name "${collision.name}" (id: ${collision.id}) in this scope. Use merge-tags to combine them instead of renaming.`
     );
   }
   const [updated] = await db.update(schema_exports.tags).set({ name: nextName, projectId: nextProjectId }).where(eq(schema_exports.tags.id, existing.id)).returning(TAG_COLUMNS);
-  if (!updated) return textResponse6(`Failed to update tag ${input.tagId}.`);
-  return textResponse6(
+  if (!updated) return textResponse8(`Failed to update tag ${input.tagId}.`);
+  return textResponse8(
     `\u2705 **Tag updated**
 
 ${describeTag(updated)}
@@ -121799,34 +122790,34 @@ Existing ticket/customer/project/transaction tag relations are preserved.`
   );
 }
 async function handleDeleteTag(input) {
-  if (!input.tagId) return textResponse6("Error: `tagId` is required.");
+  if (!input.tagId) return textResponse8("Error: `tagId` is required.");
   const mode = input.mode ?? "delete_if_unused";
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const existing = await loadTagInTeam(input.tagId, resolved.teamId);
   if (!existing) {
-    return textResponse6(
+    return textResponse8(
       `Tag ${input.tagId} not found, or it is not owned by this team.`
     );
   }
   const usage = await getTagUsage(existing.id);
   const total = totalTagUsage(usage);
   if (mode === "archive") {
-    return textResponse6(
+    return textResponse8(
       `\u2139\uFE0F Archiving is not supported for team tags: the \`tags\` table has no archived column. ${describeTag(existing)} is used by ${formatTagUsage(usage)}.
 
 Options: use merge-tags to fold it into another tag, or delete it once it is unused (mode: delete_if_unused).`
     );
   }
   if (total > 0) {
-    return textResponse6(
+    return textResponse8(
       `\u274C Refusing to delete ${describeTag(existing)}: it is still used by ${formatTagUsage(usage)}. Deleting would strip the tag off those entities.
 
 Use merge-tags to move usage onto another tag first, then delete the (now-empty) tag.`
     );
   }
   await db.delete(schema_exports.tags).where(eq(schema_exports.tags.id, existing.id));
-  return textResponse6(
+  return textResponse8(
     `\u2705 **Tag deleted** (was unused): ${describeTag(existing)}`
   );
 }
@@ -121836,7 +122827,7 @@ async function resolveMergeTarget(teamId, input) {
     if (!tag) {
       return {
         ok: false,
-        response: textResponse6(
+        response: textResponse8(
           `Target tag ${input.targetTagId} not found, or it is not owned by this team.`
         )
       };
@@ -121846,7 +122837,7 @@ async function resolveMergeTarget(teamId, input) {
   if (!isValidTagName(input.targetName)) {
     return {
       ok: false,
-      response: textResponse6(
+      response: textResponse8(
         "Error: provide either `targetTagId` or a non-empty `targetName`."
       )
     };
@@ -121864,14 +122855,14 @@ async function resolveMergeTarget(teamId, input) {
   }
   const [created] = await db.insert(schema_exports.tags).values({ teamId, name: input.targetName.trim(), projectId: null }).returning(TAG_COLUMNS);
   if (!created) {
-    return { ok: false, response: textResponse6("Failed to create target tag.") };
+    return { ok: false, response: textResponse8("Failed to create target tag.") };
   }
   return { ok: true, tag: created, created: true };
 }
 async function handleMergeTags(input) {
   const rawSourceIds = [...new Set(input.sourceTagIds ?? [])].filter(Boolean);
   if (rawSourceIds.length === 0) {
-    return textResponse6("Error: `sourceTagIds` must contain at least one tag id.");
+    return textResponse8("Error: `sourceTagIds` must contain at least one tag id.");
   }
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
@@ -121885,7 +122876,7 @@ async function handleMergeTags(input) {
   const foundIds = new Set(sourceTags.map((t8) => t8.id));
   const missing = rawSourceIds.filter((id) => !foundIds.has(id));
   if (missing.length > 0) {
-    return textResponse6(
+    return textResponse8(
       `Error: source tag(s) not found or not owned by this team: ${missing.join(", ")}.`
     );
   }
@@ -121893,7 +122884,7 @@ async function handleMergeTags(input) {
   if (!target.ok) return target.response;
   const sourcesToMerge = sourceTags.filter((t8) => t8.id !== target.tag.id);
   if (sourcesToMerge.length === 0) {
-    return textResponse6(
+    return textResponse8(
       "Error: nothing to merge \u2014 the only source tag is the same as the target tag."
     );
   }
@@ -121990,7 +122981,7 @@ async function handleMergeTags(input) {
   const movedTotal = results.tickets.moved + results.customers.moved + results.projects.moved + results.transactions.moved;
   const skippedTotal = results.tickets.skipped + results.customers.skipped + results.projects.skipped + results.transactions.skipped;
   const line2 = (label, r6) => `- ${label}: ${r6.moved} moved, ${r6.skipped} skipped (duplicate)`;
-  return textResponse6(
+  return textResponse8(
     `\u2705 **Tags merged** into ${describeTag(target.tag)}${target.created ? " (newly created)" : ""}
 
 Sources (${sourcesToMerge.length}): ${sourcesToMerge.map((t8) => `${t8.name} (${t8.id})`).join(", ")}
@@ -122357,15 +123348,15 @@ var TRIP_LOCKED_FIELDS = [
   "invoiceId",
   "isInvoiced"
 ];
-function round22(value) {
+function round23(value) {
   return Math.round(value * 100) / 100;
 }
 function deriveTripAmount(input) {
   if (input.amount != null) return input.amount;
   if (input.rate == null) return null;
-  if (input.billingType === "per_trip") return round22(input.rate);
+  if (input.billingType === "per_trip") return round23(input.rate);
   if (input.billingType === "per_km" && input.distance != null) {
-    return round22(input.distance * input.rate);
+    return round23(input.distance * input.rate);
   }
   return null;
 }
@@ -122376,7 +123367,7 @@ function attemptedLockedFields(update) {
 // src/tools/trips.ts
 var TRIP_TYPES = ["private", "business"];
 var BILLING_TYPES2 = TRIP_BILLING_TYPES;
-function textResponse7(text3) {
+function textResponse9(text3) {
   return { content: [{ type: "text", text: text3 }] };
 }
 function jsonResponse(payload) {
@@ -122432,19 +123423,19 @@ var TRIP_RELATIONS = {
 };
 async function handleGetTrips(input) {
   if (input.tripType && !TRIP_TYPES.includes(input.tripType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: invalid tripType "${input.tripType}". Allowed: ${TRIP_TYPES.join(", ")}.`
     );
   }
   if (input.billingType && !BILLING_TYPES2.includes(input.billingType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES2.join(", ")}.`
     );
   }
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse7("No accessible teams found.");
+    return textResponse9("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.trips.teamId, scope.teamIds)];
   if (input.dateFrom) filters.push(gte(schema_exports.trips.date, input.dateFrom));
@@ -122489,10 +123480,10 @@ async function handleGetTrips(input) {
   return jsonResponse({
     count: rows.length,
     totals: {
-      businessKm: round22(totals.businessKm),
-      privateKm: round22(totals.privateKm),
-      totalKm: round22(totals.totalKm),
-      totalAmount: round22(totals.totalAmount)
+      businessKm: round23(totals.businessKm),
+      privateKm: round23(totals.privateKm),
+      totalKm: round23(totals.totalKm),
+      totalAmount: round23(totals.totalAmount)
     },
     trips: rows.map(formatTrip)
   });
@@ -122546,20 +123537,20 @@ async function validateInvoice(invoiceId, teamId) {
 }
 async function handleCreateTrip(input) {
   const ctx = getAuthContext();
-  if (!input.date) return textResponse7("Error: `date` (YYYY-MM-DD) is required.");
+  if (!input.date) return textResponse9("Error: `date` (YYYY-MM-DD) is required.");
   if (!input.startLocation || !input.endLocation) {
-    return textResponse7(
+    return textResponse9(
       "Error: `startLocation` and `endLocation` are required."
     );
   }
   if (!input.tripType || !TRIP_TYPES.includes(input.tripType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: \`tripType\` is required and must be one of: ${TRIP_TYPES.join(", ")}.`
     );
   }
   const billingType = input.billingType ?? "not_billable";
   if (!BILLING_TYPES2.includes(billingType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES2.join(", ")}.`
     );
   }
@@ -122571,7 +123562,7 @@ async function handleCreateTrip(input) {
     customerId: input.customerId,
     vehicleId: input.vehicleId
   });
-  if (linkError) return textResponse7(`Error: ${linkError}`);
+  if (linkError) return textResponse9(`Error: ${linkError}`);
   if (!input.allowDuplicate) {
     const dupFilters = [
       eq(schema_exports.trips.teamId, teamId),
@@ -122588,7 +123579,7 @@ async function handleCreateTrip(input) {
     }
     const [dup] = await db.select({ id: schema_exports.trips.id, distance: schema_exports.trips.distance }).from(schema_exports.trips).where(and(...dupFilters)).limit(1);
     if (dup) {
-      return textResponse7(
+      return textResponse9(
         `\u26A0\uFE0F A matching trip already exists for ${input.date} (${input.startLocation} \u2192 ${input.endLocation}): trip ${dup.id}${dup.distance != null ? ` (${toNumber2(dup.distance)} km)` : ""}. Not creating a duplicate. Use update-trip to adjust it, or re-call create-trip with allowDuplicate: true to record a second trip anyway.`
       );
     }
@@ -122618,7 +123609,7 @@ async function handleCreateTrip(input) {
     vehicleId: input.vehicleId ?? null,
     snapshotId: input.snapshotId ?? null
   }).returning({ id: schema_exports.trips.id });
-  if (!created) return textResponse7("Failed to create trip.");
+  if (!created) return textResponse9("Failed to create trip.");
   const trip = await loadTripInTeams(created.id, [teamId]);
   return {
     content: [
@@ -122633,14 +123624,14 @@ ${JSON.stringify(formatTrip(trip), null, 2)}`
 }
 async function handleUpdateTrip(input) {
   const ctx = getAuthContext();
-  if (!input.id) return textResponse7("Error: `id` is required.");
+  if (!input.id) return textResponse9("Error: `id` is required.");
   if (input.tripType && !TRIP_TYPES.includes(input.tripType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: invalid tripType "${input.tripType}". Allowed: ${TRIP_TYPES.join(", ")}.`
     );
   }
   if (input.billingType && !BILLING_TYPES2.includes(input.billingType)) {
-    return textResponse7(
+    return textResponse9(
       `Error: invalid billingType "${input.billingType}". Allowed: ${BILLING_TYPES2.join(", ")}.`
     );
   }
@@ -122649,7 +123640,7 @@ async function handleUpdateTrip(input) {
   const accessibleTeamIds = await getAccessibleTeamIds(resolved.teamId);
   const existing = await loadTripInTeams(input.id, accessibleTeamIds);
   if (!existing) {
-    return textResponse7(
+    return textResponse9(
       `Trip ${input.id} not found or you don't have access to it. Call get-trips to find a valid id.`
     );
   }
@@ -122660,7 +123651,7 @@ async function handleUpdateTrip(input) {
       input
     );
     if (attempted.length > 0) {
-      return textResponse7(
+      return textResponse9(
         `Error: trip ${input.id} is invoiced${existing.invoiceId ? ` (invoice ${existing.invoiceId})` : ""}. Financial/distance fields are locked: ${attempted.join(", ")}. Re-call with allowInvoicedOverride: true to change them anyway, or only update project/customer/notes/vehicle links.`
       );
     }
@@ -122670,10 +123661,10 @@ async function handleUpdateTrip(input) {
     customerId: input.customerId ?? void 0,
     vehicleId: input.vehicleId ?? void 0
   });
-  if (linkError) return textResponse7(`Error: ${linkError}`);
+  if (linkError) return textResponse9(`Error: ${linkError}`);
   if (input.invoiceId) {
     const invoiceError = await validateInvoice(input.invoiceId, teamId);
-    if (invoiceError) return textResponse7(`Error: ${invoiceError}`);
+    if (invoiceError) return textResponse9(`Error: ${invoiceError}`);
   }
   const updates = {};
   if (input.date !== void 0) updates.date = input.date;
@@ -122721,7 +123712,7 @@ async function handleUpdateTrip(input) {
     if (derived != null) updates.amount = derived;
   }
   if (Object.keys(updates).length === 0) {
-    return textResponse7(
+    return textResponse9(
       "No fields to update. Provide at least one editable field."
     );
   }
@@ -122748,7 +123739,7 @@ async function handleGetVehicles(input) {
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse7("No accessible teams found.");
+    return textResponse9("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.vehicles.teamId, scope.teamIds)];
   if (input.q) filters.push(ilike(schema_exports.vehicles.name, `%${input.q}%`));
@@ -122774,7 +123765,7 @@ async function handleGetTripTemplates(input) {
   const scope = await resolveTeamScope(input.teamId);
   if (!scope.ok) return scope.response;
   if (scope.teamIds.length === 0) {
-    return textResponse7("No accessible teams found.");
+    return textResponse9("No accessible teams found.");
   }
   const filters = [inArray(schema_exports.tripTemplates.teamId, scope.teamIds)];
   const userId = input.userId ?? ctx.userId;
@@ -122810,14 +123801,14 @@ async function handleGetTripTemplates(input) {
 async function handleGetFrequentTripsForProject(input) {
   const ctx = getAuthContext();
   if (!input.projectId) {
-    return textResponse7("Error: `projectId` is required.");
+    return textResponse9("Error: `projectId` is required.");
   }
   const resolved = await resolveTeamId(input.teamId);
   if (!resolved.ok) return resolved.response;
   const teamId = resolved.teamId;
   const projectIds = await getAccessibleProjectIds(ctx.userId, teamId);
   if (!projectIds.includes(input.projectId)) {
-    return textResponse7(
+    return textResponse9(
       `Project not found or no access: ${input.projectId}. Call get-projects first.`
     );
   }
@@ -122852,7 +123843,7 @@ async function handleGetFrequentTripsForProject(input) {
       endLocation: g6.endLocation,
       tripType: g6.tripType,
       count: g6.count,
-      avgDistance: g6.avgDistance != null ? round22(toNumber2(g6.avgDistance)) : null,
+      avgDistance: g6.avgDistance != null ? round23(toNumber2(g6.avgDistance)) : null,
       lastUsedDate: g6.lastUsedDate
     }))
   });
@@ -123442,6 +124433,22 @@ function createMcpServer() {
           );
         case "get-invoices":
           return await handleGetInvoices(asToolArgs(toolArgs));
+        case "get-invoice-by-id":
+          return await handleGetInvoiceById(
+            asToolArgs(toolArgs)
+          );
+        case "update-invoice":
+          return await handleUpdateInvoice(
+            asToolArgs(toolArgs)
+          );
+        case "update-invoice-lines":
+          return await handleUpdateInvoiceLines(
+            asToolArgs(toolArgs)
+          );
+        case "add-product-to-invoice":
+          return await handleAddProductToInvoice(
+            asToolArgs(toolArgs)
+          );
         case "link-document-to-invoice":
           return await handleLinkDocumentToInvoice(
             asToolArgs(toolArgs)
@@ -123464,6 +124471,18 @@ function createMcpServer() {
           return await handleArchiveProduct(
             asToolArgs(toolArgs)
           );
+        case "get-customer-agreements":
+          return await handleGetCustomerAgreements(
+            asToolArgs(toolArgs)
+          );
+        case "create-customer-agreement":
+          return await handleCreateCustomerAgreement(
+            asToolArgs(toolArgs)
+          );
+        case "update-customer-agreement":
+          return await handleUpdateCustomerAgreement(
+            asToolArgs(toolArgs)
+          );
         case "get-trips":
           return await handleGetTrips(asToolArgs(toolArgs));
         case "create-trip":