@kirjapro/mcp-server 0.2.0 → 0.5.0

package/dist/index.js

@@ -20891,6 +20891,7 @@ function scheduleTokenRefresh(apiKey, expiresIn) {
       console.error("[kirjapro-mcp] Refreshing API key token...");
       const auth = await authenticateWithApiKey(apiKey);
       supabase = createClientFromAuth(auth);
+      companyId = auth.company_id;
       console.error("[kirjapro-mcp] Token refreshed successfully");
     } catch (error2) {
       console.error("[kirjapro-mcp] Token refresh failed:", error2.message);
@@ -20925,7 +20926,8 @@ async function initLegacyAuth() {
   if (!kirjaproCompanyId) {
     throw new Error("KIRJAPRO_COMPANY_ID environment variable is required.");
   }
-  supabase = createClient(supabaseUrl, supabaseAccessToken, {
+  const anonKey = process.env.SUPABASE_ANON_KEY || supabaseAccessToken;
+  supabase = createClient(supabaseUrl, anonKey, {
     auth: {
       persistSession: false,
       autoRefreshToken: false
@@ -21018,7 +21020,7 @@ function toTextContent(data) {
     content: [
       {
         type: "text",
-        text: JSON.stringify(data, null, 2)
+        text: JSON.stringify(data)
       }
     ]
   };
@@ -21029,12 +21031,79 @@ function toErrorContent(message) {
     isError: true
   };
 }
+var SAFE_ERROR_MAP = {
+  PGRST116: "Record not found.",
+  PGRST301: "Request timed out. Try a narrower query.",
+  "23505": "A record with this value already exists (duplicate).",
+  "23503": "Referenced record does not exist.",
+  "23514": "Value violates a constraint. Check your input.",
+  "42501": "Permission denied.",
+  "42P01": "Data not available."
+};
+function sanitizeDbError(context, error2) {
+  console.error(`[kirjapro-mcp] ${context}:`, {
+    code: error2.code,
+    message: error2.message,
+    details: error2.details,
+    hint: error2.hint
+  });
+  if (error2.code && SAFE_ERROR_MAP[error2.code]) {
+    return `${context}: ${SAFE_ERROR_MAP[error2.code]}`;
+  }
+  if (error2.message) {
+    const stripped = error2.message.replace(/relation "[^"]*"/g, "table").replace(/constraint "[^"]*"/g, "constraint").replace(/column "[^"]*"/g, "column").replace(/schema "[^"]*"/g, "schema").replace(/function "[^"]*"/g, "function");
+    return `${context}: ${stripped}`;
+  }
+  return `${context}. Please try again.`;
+}
+async function invokeEdgeFunction(supabase2, name, body) {
+  const { data, error: error2 } = await supabase2.functions.invoke(name, { body });
+  if (error2) {
+    console.error(`[kirjapro-mcp] Edge function "${name}" error:`, error2.message);
+    return { data: null, error: `Edge function "${name}" failed: ${error2.message}` };
+  }
+  return { data, error: null };
+}
 function roundCents(amount) {
   return Math.round(amount * 100) / 100;
 }
+function addDaysToIsoDate(date3, days) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date3);
+  if (!match) {
+    throw new Error(`Invalid ISO date: ${date3}`);
+  }
+  const year = Number.parseInt(match[1], 10);
+  const month = Number.parseInt(match[2], 10);
+  const day = Number.parseInt(match[3], 10);
+  const utcDate = new Date(Date.UTC(year, month - 1, day));
+  utcDate.setUTCDate(utcDate.getUTCDate() + days);
+  return utcDate.toISOString().slice(0, 10);
+}
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    value
+  );
+}
 function escapeLike(input) {
   return input.replace(/[%_\\]/g, "\\$&");
 }
+async function resolveOpenFiscalYear(supabase2, companyId2) {
+  const { data, error: error2 } = await supabase2.from("fiscal_years").select("id").eq("company_id", companyId2).eq("is_closed", false);
+  if (error2) {
+    return toErrorContent(sanitizeDbError("Failed to query fiscal years", error2));
+  }
+  if (!data || data.length === 0) {
+    return toErrorContent(
+      "No open fiscal year found. Create one or specify fiscalYearId explicitly."
+    );
+  }
+  if (data.length > 1) {
+    return toErrorContent(
+      `Multiple open fiscal years found (${data.length}). Specify fiscalYearId explicitly. Read kirjapro://fiscal-years to list them.`
+    );
+  }
+  return { id: data[0].id };
+}
 
 // src/tools/accounts.ts
 function registerAccountTools(server2) {
@@ -21046,13 +21115,15 @@ function registerAccountTools(server2) {
       offset: external_exports.number().min(0).default(0).describe("Skip first N results"),
       accountType: external_exports.enum(["asset", "liability", "equity", "revenue", "expense"]).optional().describe("Filter by account type"),
       search: external_exports.string().optional().describe("Search by account name or number"),
-      activeOnly: external_exports.boolean().default(true).describe("Only show active accounts")
+      activeOnly: external_exports.boolean().default(true).describe("Only show active accounts"),
+      includeIds: external_exports.boolean().default(false).describe("Include UUID id and parent_id fields (rarely needed)")
     },
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
       const { limit, offset } = clampPagination(params.limit, params.offset);
-      let query = supabase2.from("accounts").select("id, account_number, name, account_type, parent_id, is_active", { count: "exact" }).eq("company_id", companyId2).order("account_number");
+      const selectCols = params.includeIds ? "id, account_number, name, account_type, parent_id, is_active" : "account_number, name, account_type";
+      let query = supabase2.from("accounts").select(selectCols, { count: "exact" }).eq("company_id", companyId2).order("account_number");
       if (params.activeOnly) {
         query = query.eq("is_active", true);
       }
@@ -21066,7 +21137,7 @@ function registerAccountTools(server2) {
       query = query.range(offset, offset + limit - 1);
       const { data, count, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to list accounts: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list accounts", error2));
       }
       return toTextContent(paginate(data || [], count || 0, offset, limit));
     }
@@ -21079,7 +21150,7 @@ function registerTransactionTools(server2) {
     "kirjapro_list_transactions",
     "List accounting transactions (tositteet) with their journal entries for a fiscal year. Returns transaction date, description, and debit/credit entries with account details.",
     {
-      fiscalYearId: external_exports.string().uuid().describe("Fiscal year UUID to filter transactions"),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
       limit: external_exports.number().min(1).max(200).default(50).describe("Max results (default 50)"),
       offset: external_exports.number().min(0).default(0).describe("Skip first N results")
     },
@@ -21087,23 +21158,46 @@ function registerTransactionTools(server2) {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
       const { limit, offset } = clampPagination(params.limit, params.offset);
-      const { data, count, error: error2 } = await supabase2.from("transactions").select(`
+      let fiscalYearId = params.fiscalYearId;
+      if (!fiscalYearId) {
+        const resolved = await resolveOpenFiscalYear(supabase2, companyId2);
+        if ("isError" in resolved) return resolved;
+        fiscalYearId = resolved.id;
+      }
+      const { data, count, error: error2 } = await supabase2.from("transactions").select(
+        `
           id, transaction_date, description, document_number, created_at,
           journal_entries (
             id, account_id, debit_amount, credit_amount,
             accounts ( account_number, name )
           )
-        `, { count: "exact" }).eq("company_id", companyId2).eq("fiscal_year_id", params.fiscalYearId).order("transaction_date", { ascending: false }).range(offset, offset + limit - 1);
+        `,
+        { count: "exact" }
+      ).eq("company_id", companyId2).eq("fiscal_year_id", fiscalYearId).order("transaction_date", { ascending: false }).range(offset, offset + limit - 1);
       if (error2) {
-        return toErrorContent(`Failed to list transactions: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list transactions", error2));
       }
       const transactions = (data || []).map((t) => ({
-        ...t,
+        id: t.id,
+        transaction_date: t.transaction_date,
+        description: t.description,
+        document_number: t.document_number,
+        entries: (t.journal_entries || []).map((e) => ({
+          account: `${e.accounts?.account_number} ${e.accounts?.name}`,
+          debit: e.debit_amount || 0,
+          credit: e.credit_amount || 0
+        })),
         total_debit: roundCents(
-          (t.journal_entries || []).reduce((s, e) => s + (e.debit_amount || 0), 0)
+          (t.journal_entries || []).reduce(
+            (s, e) => s + (e.debit_amount || 0),
+            0
+          )
         ),
         total_credit: roundCents(
-          (t.journal_entries || []).reduce((s, e) => s + (e.credit_amount || 0), 0)
+          (t.journal_entries || []).reduce(
+            (s, e) => s + (e.credit_amount || 0),
+            0
+          )
         )
       }));
       return toTextContent(paginate(transactions, count || 0, offset, limit));
@@ -21125,13 +21219,16 @@ function registerTransactionTools(server2) {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
       const { limit, offset } = clampPagination(params.limit, params.offset);
-      let query = supabase2.from("transactions").select(`
+      let query = supabase2.from("transactions").select(
+        `
           id, transaction_date, description, document_number, created_at,
           journal_entries (
             id, debit_amount, credit_amount,
             accounts ( account_number, name )
           )
-        `, { count: "exact" }).eq("company_id", companyId2).order("transaction_date", { ascending: false });
+        `,
+        { count: "exact" }
+      ).eq("company_id", companyId2).order("transaction_date", { ascending: false });
       if (params.query) {
         query = query.ilike("description", `%${escapeLike(params.query)}%`);
       }
@@ -21141,56 +21238,95 @@ function registerTransactionTools(server2) {
       if (params.dateTo) {
         query = query.lte("transaction_date", params.dateTo);
       }
-      query = query.range(offset, offset + limit - 1);
+      const hasAmountFilter = params.minAmount !== void 0 || params.maxAmount !== void 0;
+      const AMOUNT_FILTER_CAP = 1e3;
+      if (hasAmountFilter) {
+        query = query.range(0, AMOUNT_FILTER_CAP - 1);
+      } else {
+        query = query.range(offset, offset + limit - 1);
+      }
       const { data, count, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to search transactions: ${error2.message}`);
-      }
-      let results = (data || []).map((t) => {
-        const totalDebit = roundCents(
-          (t.journal_entries || []).reduce((s, e) => s + (e.debit_amount || 0), 0)
-        );
-        const totalCredit = roundCents(
-          (t.journal_entries || []).reduce((s, e) => s + (e.credit_amount || 0), 0)
+        return toErrorContent(
+          "Failed to search transactions. Check your filters and try again."
         );
-        return { ...t, total_debit: totalDebit, total_credit: totalCredit };
-      });
-      if (params.minAmount !== void 0) {
-        results = results.filter((t) => t.total_debit >= params.minAmount);
       }
-      if (params.maxAmount !== void 0) {
-        results = results.filter((t) => t.total_debit <= params.maxAmount);
+      let results = (data || []).map(
+        (t) => {
+          const totalDebit = roundCents(
+            (t.journal_entries || []).reduce(
+              (s, e) => s + (e.debit_amount || 0),
+              0
+            )
+          );
+          const totalCredit = roundCents(
+            (t.journal_entries || []).reduce(
+              (s, e) => s + (e.credit_amount || 0),
+              0
+            )
+          );
+          return {
+            id: t.id,
+            transaction_date: t.transaction_date,
+            description: t.description,
+            document_number: t.document_number,
+            entries: (t.journal_entries || []).map((e) => ({
+              account: `${e.accounts?.account_number} ${e.accounts?.name}`,
+              debit: e.debit_amount || 0,
+              credit: e.credit_amount || 0
+            })),
+            total_debit: totalDebit,
+            total_credit: totalCredit
+          };
+        }
+      );
+      if (hasAmountFilter) {
+        if (params.minAmount !== void 0) {
+          results = results.filter((t) => t.total_debit >= params.minAmount);
+        }
+        if (params.maxAmount !== void 0) {
+          results = results.filter((t) => t.total_debit <= params.maxAmount);
+        }
+        const filteredTotal = results.length;
+        const paginatedResults = results.slice(offset, offset + limit);
+        const cappedWarning = (count || 0) >= AMOUNT_FILTER_CAP ? " (results capped at 1000 rows \u2014 narrow your date range for complete results)" : "";
+        return toTextContent({
+          ...paginate(paginatedResults, filteredTotal, offset, limit),
+          amount_filter_note: `Filtered client-side from ${count || 0} transactions${cappedWarning}`
+        });
       }
-      const hasAmountFilter = params.minAmount !== void 0 || params.maxAmount !== void 0;
-      return toTextContent(paginate(
-        results,
-        hasAmountFilter ? results.length : count || 0,
-        offset,
-        limit
-      ));
+      return toTextContent(paginate(results, count || 0, offset, limit));
     }
   );
   server2.tool(
     "kirjapro_create_transaction",
-    'Create a new accounting transaction (tosite) with journal entries. Entries must balance (total debits = total credits). Accepts account numbers (e.g. "4000") which are resolved to UUIDs server-side.',
+    "Create a transaction (tosite) with journal entries. Entries must balance (debits = credits). Accepts account numbers resolved to UUIDs server-side. Prefer kirjapro_create_from_template for standard patterns.",
     {
-      fiscalYearId: external_exports.string().uuid().describe("Fiscal year UUID"),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
       transactionDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Transaction date (YYYY-MM-DD)"),
       description: external_exports.string().min(1).max(500).describe("Transaction description"),
       documentNumber: external_exports.string().optional().describe("Document/receipt number"),
-      entries: external_exports.array(external_exports.object({
-        accountNumber: external_exports.string().describe('Account number (e.g. "4000") or UUID'),
-        debitAmount: external_exports.number().min(0).default(0).describe("Debit amount in EUR"),
-        creditAmount: external_exports.number().min(0).default(0).describe("Credit amount in EUR")
-      })).min(2).describe("Journal entries (min 2, must balance)")
+      entries: external_exports.array(
+        external_exports.object({
+          accountNumber: external_exports.string().describe('Account number (e.g. "4000") or UUID'),
+          debitAmount: external_exports.number().min(0).default(0).describe("Debit amount in EUR"),
+          creditAmount: external_exports.number().min(0).default(0).describe("Credit amount in EUR")
+        })
+      ).min(2).describe("Journal entries (min 2, must balance)")
     },
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: fy, error: fyError } = await supabase2.from("fiscal_years").select("id, is_closed, start_date, end_date").eq("id", params.fiscalYearId).eq("company_id", companyId2).single();
+      let fiscalYearId = params.fiscalYearId;
+      if (!fiscalYearId) {
+        const resolved = await resolveOpenFiscalYear(supabase2, companyId2);
+        if ("isError" in resolved) return resolved;
+        fiscalYearId = resolved.id;
+      }
+      const { data: fy, error: fyError } = await supabase2.from("fiscal_years").select("id, is_closed, start_date, end_date").eq("id", fiscalYearId).eq("company_id", companyId2).single();
       if (fyError || !fy) {
         return toErrorContent(
-          `Fiscal year ${params.fiscalYearId} not found. Use kirjapro_get_dashboard with a valid fiscal year ID, or read the kirjapro://fiscal-years resource to list available fiscal years.`
+          `Fiscal year ${fiscalYearId} not found. Use kirjapro_get_dashboard with a valid fiscal year ID, or read the kirjapro://fiscal-years resource to list available fiscal years.`
         );
       }
       if (fy.is_closed) {
@@ -21203,52 +21339,85 @@ function registerTransactionTools(server2) {
           `Transaction date ${params.transactionDate} is outside fiscal year range (${fy.start_date} to ${fy.end_date}).`
         );
       }
-      const accountNumbers = params.entries.map((e) => e.accountNumber);
-      const { data: accounts, error: accError } = await supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("account_number", accountNumbers);
+      const accountIdentifiers = params.entries.map((e) => e.accountNumber);
+      const uuidIdentifiers = [
+        ...new Set(
+          accountIdentifiers.filter((identifier) => isUuid(identifier))
+        )
+      ];
+      const numberIdentifiers = [
+        ...new Set(
+          accountIdentifiers.filter((identifier) => !isUuid(identifier))
+        )
+      ];
+      const [accountsByNumber, accountsById] = await Promise.all([
+        numberIdentifiers.length > 0 ? supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("account_number", numberIdentifiers) : Promise.resolve({ data: [], error: null }),
+        uuidIdentifiers.length > 0 ? supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("id", uuidIdentifiers) : Promise.resolve({ data: [], error: null })
+      ]);
+      const accError = accountsByNumber.error || accountsById.error;
       if (accError) {
-        return toErrorContent(`Failed to resolve accounts: ${accError.message}`);
+        return toErrorContent(
+          sanitizeDbError("Failed to resolve accounts", accError)
+        );
+      }
+      const accounts = [
+        ...accountsByNumber.data || [],
+        ...accountsById.data || []
+      ];
+      const accountMap = /* @__PURE__ */ new Map();
+      for (const account of accounts) {
+        accountMap.set(account.account_number, account.id);
+        accountMap.set(account.id, account.id);
       }
-      const accountMap = new Map((accounts || []).map((a) => [a.account_number, a.id]));
-      const missingAccounts = accountNumbers.filter((n) => !accountMap.has(n));
+      const missingAccounts = accountIdentifiers.filter(
+        (identifier) => !accountMap.has(identifier)
+      );
       if (missingAccounts.length > 0) {
         return toErrorContent(
-          `Account numbers not found: ${missingAccounts.join(", ")}. Use kirjapro_list_accounts to see available accounts.`
+          `Accounts not found: ${missingAccounts.join(", ")}. Use kirjapro_list_accounts to see available accounts.`
         );
       }
-      const totalDebit = roundCents(params.entries.reduce((s, e) => s + e.debitAmount, 0));
-      const totalCredit = roundCents(params.entries.reduce((s, e) => s + e.creditAmount, 0));
+      const totalDebit = roundCents(
+        params.entries.reduce((s, e) => s + e.debitAmount, 0)
+      );
+      const totalCredit = roundCents(
+        params.entries.reduce((s, e) => s + e.creditAmount, 0)
+      );
       if (totalDebit !== totalCredit) {
         return toErrorContent(
           `Transaction is unbalanced: total debits (${totalDebit.toFixed(2)}) != total credits (${totalCredit.toFixed(2)}). Difference: ${Math.abs(totalDebit - totalCredit).toFixed(2)} EUR. Add a ${totalDebit > totalCredit ? "credit" : "debit"} entry of ${Math.abs(totalDebit - totalCredit).toFixed(2)} to balance.`
         );
       }
-      const { data: transaction, error: txError } = await supabase2.from("transactions").insert({
-        company_id: companyId2,
-        fiscal_year_id: params.fiscalYearId,
-        transaction_date: params.transactionDate,
-        description: params.description,
-        document_number: params.documentNumber || null
-      }).select().single();
-      if (txError) {
-        return toErrorContent(`Failed to create transaction: ${txError.message}`);
-      }
       const journalEntries = params.entries.map((e) => ({
-        transaction_id: transaction.id,
         account_id: accountMap.get(e.accountNumber),
         debit_amount: e.debitAmount,
         credit_amount: e.creditAmount
       }));
-      const { error: jeError } = await supabase2.from("journal_entries").insert(journalEntries);
-      if (jeError) {
-        return toErrorContent(`Transaction created but journal entries failed: ${jeError.message}`);
+      const { data: transactionId, error: txError } = await supabase2.rpc(
+        "create_transaction_with_entries",
+        {
+          p_company_id: companyId2,
+          p_fiscal_year_id: fiscalYearId,
+          p_transaction_date: params.transactionDate,
+          p_description: params.description,
+          p_document_number: params.documentNumber || "",
+          p_entries: journalEntries
+        }
+      );
+      if (txError || !transactionId) {
+        return toErrorContent(
+          txError ? sanitizeDbError("Failed to create transaction", txError) : "Failed to create transaction: no ID returned."
+        );
       }
-      const { data: complete } = await supabase2.from("transactions").select(`
+      const { data: complete } = await supabase2.from("transactions").select(
+        `
           id, transaction_date, description, document_number, created_at,
           journal_entries (
             id, debit_amount, credit_amount,
             accounts ( account_number, name )
           )
-        `).eq("id", transaction.id).single();
+        `
+      ).eq("id", transactionId).single();
       return toTextContent({
         message: "Transaction created successfully",
         transaction: complete
@@ -21257,77 +21426,136 @@ function registerTransactionTools(server2) {
   );
   server2.tool(
     "kirjapro_create_transactions_batch",
-    "Create multiple accounting transactions in one call (up to 50). Ideal for bulk import from bank statements or receipts. Each transaction is validated independently \u2014 valid ones are created even if others fail.",
+    "Create multiple transactions in one call (up to 50). Each must balance (debits = credits) and is validated independently. Prefer kirjapro_create_from_template_batch for standard patterns.",
     {
-      fiscalYearId: external_exports.string().uuid().describe("Fiscal year UUID"),
-      transactions: external_exports.array(external_exports.object({
-        transactionDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Date (YYYY-MM-DD)"),
-        description: external_exports.string().min(1).max(500),
-        documentNumber: external_exports.string().optional(),
-        entries: external_exports.array(external_exports.object({
-          accountNumber: external_exports.string().describe('Account number (e.g. "4000")'),
-          debitAmount: external_exports.number().min(0).default(0),
-          creditAmount: external_exports.number().min(0).default(0)
-        })).min(2)
-      })).min(1).max(50).describe("Array of transactions to create (max 50)")
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      transactions: external_exports.array(
+        external_exports.object({
+          transactionDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Date (YYYY-MM-DD)"),
+          description: external_exports.string().min(1).max(500),
+          documentNumber: external_exports.string().optional(),
+          entries: external_exports.array(
+            external_exports.object({
+              accountNumber: external_exports.string().describe('Account number (e.g. "4000")'),
+              debitAmount: external_exports.number().min(0).default(0),
+              creditAmount: external_exports.number().min(0).default(0)
+            })
+          ).min(2)
+        })
+      ).min(1).max(50).describe("Array of transactions to create (max 50)")
     },
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: fy, error: fyError } = await supabase2.from("fiscal_years").select("id, is_closed, start_date, end_date").eq("id", params.fiscalYearId).eq("company_id", companyId2).single();
+      let fiscalYearId = params.fiscalYearId;
+      if (!fiscalYearId) {
+        const resolved = await resolveOpenFiscalYear(supabase2, companyId2);
+        if ("isError" in resolved) return resolved;
+        fiscalYearId = resolved.id;
+      }
+      const { data: fy, error: fyError } = await supabase2.from("fiscal_years").select("id, is_closed, start_date, end_date").eq("id", fiscalYearId).eq("company_id", companyId2).single();
       if (fyError || !fy) {
-        return toErrorContent(`Fiscal year ${params.fiscalYearId} not found.`);
+        return toErrorContent(`Fiscal year ${fiscalYearId} not found.`);
       }
       if (fy.is_closed) {
-        return toErrorContent(`Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`);
+        return toErrorContent(
+          `Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`
+        );
+      }
+      const allAccountNumbers = [
+        ...new Set(
+          params.transactions.flatMap(
+            (t) => t.entries.map((e) => e.accountNumber)
+          )
+        )
+      ];
+      const uuidIdentifiers = allAccountNumbers.filter(
+        (identifier) => isUuid(identifier)
+      );
+      const numberIdentifiers = allAccountNumbers.filter(
+        (identifier) => !isUuid(identifier)
+      );
+      const [accountsByNumber, accountsById] = await Promise.all([
+        numberIdentifiers.length > 0 ? supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("account_number", numberIdentifiers) : Promise.resolve({ data: [], error: null }),
+        uuidIdentifiers.length > 0 ? supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("id", uuidIdentifiers) : Promise.resolve({ data: [], error: null })
+      ]);
+      const accError = accountsByNumber.error || accountsById.error;
+      if (accError) {
+        return toErrorContent(
+          sanitizeDbError("Failed to resolve accounts", accError)
+        );
+      }
+      const accounts = [
+        ...accountsByNumber.data || [],
+        ...accountsById.data || []
+      ];
+      const accountMap = /* @__PURE__ */ new Map();
+      for (const account of accounts) {
+        accountMap.set(account.account_number, account.id);
+        accountMap.set(account.id, account.id);
       }
-      const allAccountNumbers = [...new Set(
-        params.transactions.flatMap((t) => t.entries.map((e) => e.accountNumber))
-      )];
-      const { data: accounts } = await supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("account_number", allAccountNumbers);
-      const accountMap = new Map((accounts || []).map((a) => [a.account_number, a.id]));
       const created = [];
       const failed = [];
       for (let i = 0; i < params.transactions.length; i++) {
         const tx = params.transactions[i];
         if (tx.transactionDate < fy.start_date || tx.transactionDate > fy.end_date) {
-          failed.push({ index: i, error: `Date ${tx.transactionDate} outside fiscal year range.` });
+          failed.push({
+            index: i,
+            error: `Date ${tx.transactionDate} outside fiscal year range.`
+          });
           continue;
         }
-        const missing = tx.entries.filter((e) => !accountMap.has(e.accountNumber));
+        const missing = tx.entries.filter(
+          (e) => !accountMap.has(e.accountNumber)
+        );
         if (missing.length > 0) {
-          failed.push({ index: i, error: `Unknown accounts: ${missing.map((m) => m.accountNumber).join(", ")}` });
+          failed.push({
+            index: i,
+            error: `Unknown accounts: ${missing.map((m) => m.accountNumber).join(", ")}`
+          });
           continue;
         }
-        const totalDebit = roundCents(tx.entries.reduce((s, e) => s + e.debitAmount, 0));
-        const totalCredit = roundCents(tx.entries.reduce((s, e) => s + e.creditAmount, 0));
+        const totalDebit = roundCents(
+          tx.entries.reduce((s, e) => s + e.debitAmount, 0)
+        );
+        const totalCredit = roundCents(
+          tx.entries.reduce((s, e) => s + e.creditAmount, 0)
+        );
         if (totalDebit !== totalCredit) {
-          failed.push({ index: i, error: `Unbalanced: debits ${totalDebit} != credits ${totalCredit}` });
-          continue;
-        }
-        const { data: newTx, error: txErr } = await supabase2.from("transactions").insert({
-          company_id: companyId2,
-          fiscal_year_id: params.fiscalYearId,
-          transaction_date: tx.transactionDate,
-          description: tx.description,
-          document_number: tx.documentNumber || null
-        }).select("id").single();
-        if (txErr) {
-          failed.push({ index: i, error: txErr.message });
+          failed.push({
+            index: i,
+            error: `Unbalanced: debits ${totalDebit} != credits ${totalCredit}`
+          });
           continue;
         }
         const entries = tx.entries.map((e) => ({
-          transaction_id: newTx.id,
           account_id: accountMap.get(e.accountNumber),
           debit_amount: e.debitAmount,
           credit_amount: e.creditAmount
         }));
-        const { error: jeErr } = await supabase2.from("journal_entries").insert(entries);
-        if (jeErr) {
-          failed.push({ index: i, error: `Transaction created but entries failed: ${jeErr.message}` });
+        const { data: newTxId, error: txErr } = await supabase2.rpc(
+          "create_transaction_with_entries",
+          {
+            p_company_id: companyId2,
+            p_fiscal_year_id: fiscalYearId,
+            p_transaction_date: tx.transactionDate,
+            p_description: tx.description,
+            p_document_number: tx.documentNumber || "",
+            p_entries: entries
+          }
+        );
+        if (txErr || !newTxId) {
+          failed.push({
+            index: i,
+            error: txErr?.message || "No transaction ID returned"
+          });
           continue;
         }
-        created.push({ id: newTx.id, description: tx.description, date: tx.transactionDate });
+        created.push({
+          id: newTxId,
+          description: tx.description,
+          date: tx.transactionDate
+        });
       }
       return toTextContent({
         created_count: created.length,
@@ -21346,13 +21574,15 @@ function registerTransactionTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: transaction, error: error2 } = await supabase2.from("transactions").select(`
+      const { data: transaction, error: error2 } = await supabase2.from("transactions").select(
+        `
           id, transaction_date, description, document_number, created_at,
           journal_entries (
             id, account_id, debit_amount, credit_amount, description,
             accounts ( account_number, name, account_type )
           )
-        `).eq("id", params.transactionId).eq("company_id", companyId2).single();
+        `
+      ).eq("id", params.transactionId).eq("company_id", companyId2).single();
       if (error2 || !transaction) {
         return toErrorContent(
           `Transaction ${params.transactionId} not found. Use kirjapro_list_transactions to find transaction IDs.`
@@ -21376,6 +21606,14 @@ function registerTransactionTools(server2) {
 }
 
 // src/types.ts
+var VALID_OFFER_TRANSITIONS = {
+  draft: ["sent"],
+  sent: ["viewed", "accepted", "rejected", "expired", "draft"],
+  viewed: ["accepted", "rejected", "expired", "draft"],
+  accepted: ["draft"],
+  rejected: ["draft"],
+  expired: ["draft"]
+};
 var VALID_TRANSITIONS = {
   draft: ["sent", "cancelled"],
   sent: ["paid", "partial", "overdue", "cancelled", "draft"],
@@ -21399,18 +21637,12 @@ function generateReferenceNumber(baseNumber) {
   const checkDigit = (10 - sum % 10) % 10;
   return digits + checkDigit;
 }
-function generateInvoiceNumber(lastNumber, prefix = "INV") {
-  if (!lastNumber) return `${prefix}00001`;
-  const numPart = lastNumber.replace(/\D/g, "");
-  const next = parseInt(numPart || "0") + 1;
-  return `${prefix}${next.toString().padStart(5, "0")}`;
-}
 function registerInvoiceTools(server2) {
   server2.tool(
     "kirjapro_list_invoices",
     "List invoices with customer names. Filter by status (draft, sent, paid, overdue, cancelled).",
     {
-      status: external_exports.enum(["draft", "sent", "paid", "overdue", "cancelled"]).optional().describe("Filter by invoice status"),
+      status: external_exports.enum(["draft", "sent", "paid", "partial", "overdue", "cancelled"]).optional().describe("Filter by invoice status"),
       limit: external_exports.number().min(1).max(200).default(50).describe("Max results (default 50)"),
       offset: external_exports.number().min(0).default(0).describe("Skip first N results")
     },
@@ -21418,18 +21650,21 @@ function registerInvoiceTools(server2) {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
       const { limit, offset } = clampPagination(params.limit, params.offset);
-      let query = supabase2.from("invoices").select(`
+      let query = supabase2.from("invoices").select(
+        `
           id, invoice_number, reference_number, invoice_date, due_date,
           status, subtotal, vat_total, total, notes,
           customers ( name, business_id )
-        `, { count: "exact" }).eq("company_id", companyId2).order("invoice_date", { ascending: false });
+        `,
+        { count: "exact" }
+      ).eq("company_id", companyId2).order("invoice_date", { ascending: false });
       if (params.status) {
         query = query.eq("status", params.status);
       }
       query = query.range(offset, offset + limit - 1);
       const { data, count, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to list invoices: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list invoices", error2));
       }
       return toTextContent(paginate(data || [], count || 0, offset, limit));
     }
@@ -21442,13 +21677,15 @@ function registerInvoiceTools(server2) {
       invoiceDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Invoice date (YYYY-MM-DD)"),
       paymentTermDays: external_exports.number().min(0).max(365).default(14).describe("Payment term in days (default 14)"),
       notes: external_exports.string().optional().describe("Notes printed on the invoice"),
-      lines: external_exports.array(external_exports.object({
-        description: external_exports.string().min(1).describe("Line item description"),
-        quantity: external_exports.number().min(0).describe("Quantity"),
-        unit: external_exports.string().default("kpl").describe("Unit (kpl, h, kk, etc.)"),
-        unitPrice: external_exports.number().describe("Unit price in EUR (excl. VAT)"),
-        vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).default("25.5").describe("VAT rate")
-      })).min(1).describe("Invoice line items")
+      lines: external_exports.array(
+        external_exports.object({
+          description: external_exports.string().min(1).describe("Line item description"),
+          quantity: external_exports.number().min(0).describe("Quantity"),
+          unit: external_exports.string().default("kpl").describe("Unit (kpl, h, kk, etc.)"),
+          unitPrice: external_exports.number().describe("Unit price in EUR (excl. VAT)"),
+          vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).default("25.5").describe("VAT rate")
+        })
+      ).min(1).describe("Invoice line items")
     },
     async (params) => {
       const supabase2 = getSupabase();
@@ -21459,12 +21696,24 @@ function registerInvoiceTools(server2) {
           `Customer ${params.customerId} not found. Use kirjapro_list_customers to find customer IDs.`
         );
       }
-      const { data: lastInvoice } = await supabase2.from("invoices").select("invoice_number").eq("company_id", companyId2).order("created_at", { ascending: false }).limit(1).single();
-      const invoiceNumber = generateInvoiceNumber(lastInvoice?.invoice_number || null);
-      const referenceNumber = generateReferenceNumber(invoiceNumber.replace(/\D/g, ""));
-      const dueDate = new Date(params.invoiceDate);
-      dueDate.setDate(dueDate.getDate() + params.paymentTermDays);
-      const dueDateStr = dueDate.toISOString().split("T")[0];
+      const { data: invoiceNumber, error: numError } = await supabase2.rpc(
+        "get_next_invoice_number",
+        {
+          p_company_id: companyId2
+        }
+      );
+      if (numError || !invoiceNumber) {
+        return toErrorContent(
+          numError ? sanitizeDbError("Failed to generate invoice number", numError) : "Failed to generate invoice number."
+        );
+      }
+      const referenceNumber = generateReferenceNumber(
+        invoiceNumber.replace(/\D/g, "")
+      );
+      const dueDateStr = addDaysToIsoDate(
+        params.invoiceDate,
+        params.paymentTermDays
+      );
       const calculatedLines = params.lines.map((line, i) => {
         const vatRate = parseFloat(line.vatRate);
         const subtotal2 = roundCents(line.quantity * line.unitPrice);
@@ -21482,32 +21731,42 @@ function registerInvoiceTools(server2) {
           total: total2
         };
       });
-      const subtotal = roundCents(calculatedLines.reduce((s, l) => s + l.subtotal, 0));
-      const vatTotal = roundCents(calculatedLines.reduce((s, l) => s + l.vat_amount, 0));
+      const subtotal = roundCents(
+        calculatedLines.reduce((s, l) => s + l.subtotal, 0)
+      );
+      const vatTotal = roundCents(
+        calculatedLines.reduce((s, l) => s + l.vat_amount, 0)
+      );
       const total = roundCents(subtotal + vatTotal);
-      const { data: invoice, error: invError } = await supabase2.from("invoices").insert({
-        company_id: companyId2,
-        customer_id: params.customerId,
-        invoice_number: invoiceNumber,
-        reference_number: referenceNumber,
-        invoice_date: params.invoiceDate,
-        due_date: dueDateStr,
-        status: "draft",
-        subtotal,
-        vat_total: vatTotal,
-        total,
-        notes: params.notes || null
-      }).select().single();
-      if (invError) {
-        return toErrorContent(`Failed to create invoice: ${invError.message}`);
+      const { data: invoiceId, error: invError } = await supabase2.rpc(
+        "create_invoice_with_lines",
+        {
+          p_company_id: companyId2,
+          p_customer_id: params.customerId,
+          p_invoice_number: invoiceNumber,
+          p_reference_number: referenceNumber,
+          p_invoice_date: params.invoiceDate,
+          p_due_date: dueDateStr,
+          p_status: "draft",
+          p_subtotal: subtotal,
+          p_vat_total: vatTotal,
+          p_total: total,
+          p_notes: params.notes || "",
+          p_lines: calculatedLines
+        }
+      );
+      if (invError || !invoiceId) {
+        return toErrorContent(
+          invError ? sanitizeDbError("Failed to create invoice", invError) : "Failed to create invoice."
+        );
       }
-      const lineInserts = calculatedLines.map((line) => ({
-        invoice_id: invoice.id,
-        ...line
-      }));
-      const { error: lineError } = await supabase2.from("invoice_lines").insert(lineInserts);
-      if (lineError) {
-        return toErrorContent(`Invoice created but lines failed: ${lineError.message}`);
+      const { data: invoice, error: fetchError } = await supabase2.from("invoices").select(
+        "id, invoice_number, reference_number, invoice_date, due_date, status, subtotal, vat_total, total, notes, created_at"
+      ).eq("id", invoiceId).eq("company_id", companyId2).single();
+      if (fetchError || !invoice) {
+        return toErrorContent(
+          fetchError ? sanitizeDbError("Invoice created but fetch failed", fetchError) : "Invoice created but could not be retrieved."
+        );
       }
       return toTextContent({
         message: `Invoice ${invoiceNumber} created for ${customer.name}`,
@@ -21533,23 +21792,32 @@ function registerInvoiceTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: invoice, error: invError } = await supabase2.from("invoices").select(`
+      const { data: invoice, error: invError } = await supabase2.from("invoices").select(
+        `
           id, invoice_number, total, status,
           invoice_payments ( amount )
-        `).eq("id", params.invoiceId).eq("company_id", companyId2).single();
+        `
+      ).eq("id", params.invoiceId).eq("company_id", companyId2).single();
       if (invError || !invoice) {
         return toErrorContent(
           `Invoice ${params.invoiceId} not found. Use kirjapro_list_invoices to find invoice IDs.`
         );
       }
       if (invoice.status === "paid") {
-        return toErrorContent(`Invoice ${invoice.invoice_number} is already fully paid.`);
+        return toErrorContent(
+          `Invoice ${invoice.invoice_number} is already fully paid.`
+        );
       }
       if (invoice.status === "cancelled") {
-        return toErrorContent(`Invoice ${invoice.invoice_number} is cancelled and cannot accept payments.`);
+        return toErrorContent(
+          `Invoice ${invoice.invoice_number} is cancelled and cannot accept payments.`
+        );
       }
       const paidSoFar = roundCents(
-        (invoice.invoice_payments || []).reduce((s, p) => s + (p.amount || 0), 0)
+        (invoice.invoice_payments || []).reduce(
+          (s, p) => s + (p.amount || 0),
+          0
+        )
       );
       const remaining = roundCents(invoice.total - paidSoFar);
       if (params.amount > remaining + 0.01) {
@@ -21557,30 +21825,29 @@ function registerInvoiceTools(server2) {
           `Payment amount ${params.amount.toFixed(2)} exceeds remaining balance ${remaining.toFixed(2)} EUR on invoice ${invoice.invoice_number} (total: ${invoice.total.toFixed(2)}, paid: ${paidSoFar.toFixed(2)}). Reduce the payment amount to ${remaining.toFixed(2)} or less.`
         );
       }
-      const { data: payment, error: payError } = await supabase2.from("invoice_payments").insert({
-        invoice_id: params.invoiceId,
-        payment_date: params.paymentDate,
-        amount: params.amount,
-        payment_method: params.paymentMethod,
-        reference: params.reference || null,
-        notes: params.notes || null
-      }).select().single();
-      if (payError) {
-        return toErrorContent(`Failed to record payment: ${payError.message}`);
-      }
-      const newPaidTotal = roundCents(paidSoFar + params.amount);
-      const newStatus = newPaidTotal >= invoice.total ? "paid" : invoice.status;
-      if (newStatus !== invoice.status) {
-        await supabase2.from("invoices").update({
-          status: newStatus,
-          paid_date: newStatus === "paid" ? params.paymentDate : null
-        }).eq("id", params.invoiceId);
+      const { data: paymentResult, error: payError } = await supabase2.rpc(
+        "record_invoice_payment",
+        {
+          p_company_id: companyId2,
+          p_invoice_id: params.invoiceId,
+          p_payment_date: params.paymentDate,
+          p_amount: params.amount,
+          p_payment_method: params.paymentMethod,
+          p_reference: params.reference || void 0,
+          p_notes: params.notes || void 0
+        }
+      );
+      if (payError || !paymentResult) {
+        return toErrorContent(
+          payError ? sanitizeDbError("Failed to record payment", payError) : "Failed to record payment."
+        );
       }
+      const result = paymentResult;
       return toTextContent({
         message: `Payment of ${params.amount.toFixed(2)} EUR recorded on invoice ${invoice.invoice_number}`,
-        payment,
-        invoice_status: newStatus,
-        remaining_balance: roundCents(remaining - params.amount)
+        payment_id: result.payment_id,
+        invoice_status: result.invoice_status,
+        remaining_balance: result.remaining_balance
       });
     }
   );
@@ -21593,13 +21860,15 @@ function registerInvoiceTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: invoice, error: error2 } = await supabase2.from("invoices").select(`
+      const { data: invoice, error: error2 } = await supabase2.from("invoices").select(
+        `
           id, invoice_number, reference_number, invoice_date, due_date,
           status, subtotal, vat_total, total, notes, created_at,
           customers ( id, name, business_id, email, address, postal_code, city ),
           invoice_lines ( id, line_number, description, quantity, unit, unit_price, vat_rate, subtotal, vat_amount, total ),
           invoice_payments ( id, payment_date, amount, payment_method, reference )
-        `).eq("id", params.invoiceId).eq("company_id", companyId2).single();
+        `
+      ).eq("id", params.invoiceId).eq("company_id", companyId2).single();
       if (error2 || !invoice) {
         return toErrorContent(
           `Invoice ${params.invoiceId} not found. Use kirjapro_list_invoices to find invoice IDs.`
@@ -21607,7 +21876,12 @@ function registerInvoiceTools(server2) {
       }
       const vatMap = /* @__PURE__ */ new Map();
       for (const line of invoice.invoice_lines || []) {
-        const existing = vatMap.get(line.vat_rate) || { vat_rate: line.vat_rate, subtotal: 0, vat_amount: 0, total: 0 };
+        const existing = vatMap.get(line.vat_rate) || {
+          vat_rate: line.vat_rate,
+          subtotal: 0,
+          vat_amount: 0,
+          total: 0
+        };
         existing.subtotal += line.subtotal || 0;
         existing.vat_amount += line.vat_amount || 0;
         existing.total += line.total || 0;
@@ -21620,7 +21894,9 @@ function registerInvoiceTools(server2) {
         total: roundCents(v.total)
       }));
       const payments = invoice.invoice_payments || [];
-      const paidTotal = roundCents(payments.reduce((s, p) => s + (p.amount || 0), 0));
+      const paidTotal = roundCents(
+        payments.reduce((s, p) => s + (p.amount || 0), 0)
+      );
       const remainingBalance = roundCents(invoice.total - paidTotal);
       return toTextContent({
         ...invoice,
@@ -21663,9 +21939,11 @@ function registerInvoiceTools(server2) {
       if (newStatus === "paid") {
         updateFields.paid_date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
       }
-      const { error: updateError } = await supabase2.from("invoices").update(updateFields).eq("id", params.invoiceId);
+      const { error: updateError } = await supabase2.from("invoices").update(updateFields).eq("id", params.invoiceId).eq("company_id", companyId2);
       if (updateError) {
-        return toErrorContent(`Failed to update invoice status: ${updateError.message}`);
+        return toErrorContent(
+          sanitizeDbError("Failed to update invoice status", updateError)
+        );
       }
       return toTextContent({
         message: `Invoice ${invoice.invoice_number} status changed from "${currentStatus}" to "${newStatus}"`,
@@ -21695,13 +21973,23 @@ function registerInvoiceTools(server2) {
           `Cannot delete invoice ${invoice.invoice_number} \u2014 status is "${invoice.status}". Only draft invoices can be deleted. Use kirjapro_update_invoice_status to cancel it first.`
         );
       }
+      const { error: paymentsError } = await supabase2.from("invoice_payments").delete().eq("invoice_id", params.invoiceId);
+      if (paymentsError) {
+        return toErrorContent(
+          sanitizeDbError("Failed to delete invoice payments", paymentsError)
+        );
+      }
       const { error: linesError } = await supabase2.from("invoice_lines").delete().eq("invoice_id", params.invoiceId);
       if (linesError) {
-        return toErrorContent(`Failed to delete invoice lines: ${linesError.message}`);
+        return toErrorContent(
+          sanitizeDbError("Failed to delete invoice lines", linesError)
+        );
       }
       const { error: deleteError } = await supabase2.from("invoices").delete().eq("id", params.invoiceId);
       if (deleteError) {
-        return toErrorContent(`Failed to delete invoice: ${deleteError.message}`);
+        return toErrorContent(
+          sanitizeDbError("Failed to delete invoice", deleteError)
+        );
       }
       return toTextContent({
         message: `Draft invoice ${invoice.invoice_number} deleted`,
@@ -21756,7 +22044,7 @@ function registerCustomerTools(server2) {
       query = query.range(offset, offset + limit - 1);
       const { data, count, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to list customers: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list customers", error2));
       }
       return toTextContent(paginate(data || [], count || 0, offset, limit));
     }
@@ -21784,7 +22072,7 @@ function registerCustomerTools(server2) {
           `Y-tunnus '${params.businessId}' is invalid (checksum failed). Valid format: 7 digits + hyphen + check digit. Example: 1234567-8.`
         );
       }
-      const { data: lastCustomer } = await supabase2.from("customers").select("customer_number").eq("company_id", companyId2).order("created_at", { ascending: false }).limit(1).single();
+      const { data: lastCustomer } = await supabase2.from("customers").select("customer_number").eq("company_id", companyId2).order("created_at", { ascending: false }).limit(1).maybeSingle();
       const lastNum = parseInt(lastCustomer?.customer_number?.replace(/\D/g, "") || "0");
       const customerNumber = (lastNum + 1).toString().padStart(5, "0");
       const { data: customer, error: error2 } = await supabase2.from("customers").insert({
@@ -21802,7 +22090,7 @@ function registerCustomerTools(server2) {
         payment_term_days: params.paymentTermDays
       }).select().single();
       if (error2) {
-        return toErrorContent(`Failed to create customer: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to create customer", error2));
       }
       return toTextContent({
         message: `Customer "${params.name}" created with number ${customerNumber}`,
@@ -21825,12 +22113,15 @@ function registerCustomerTools(server2) {
           `Customer ${params.customerId} not found. Use kirjapro_list_customers to find customer IDs.`
         );
       }
-      const { data: invoices } = await supabase2.from("invoices").select("total, status").eq("company_id", companyId2).eq("customer_id", params.customerId);
+      const { data: invoices } = await supabase2.from("invoices").select("total, status, invoice_payments(amount)").eq("company_id", companyId2).eq("customer_id", params.customerId);
       const invoiceList = invoices || [];
       const invoiceCount = invoiceList.length;
       const totalRevenue = roundCents(invoiceList.reduce((s, i) => s + (i.total || 0), 0));
       const outstandingBalance = roundCents(
-        invoiceList.filter((i) => i.status === "sent" || i.status === "partial" || i.status === "overdue").reduce((s, i) => s + (i.total || 0), 0)
+        invoiceList.filter((i) => i.status === "sent" || i.status === "partial" || i.status === "overdue").reduce((s, i) => {
+          const paid = (i.invoice_payments || []).reduce((ps, p) => ps + (p.amount || 0), 0);
+          return s + (i.total || 0) - paid;
+        }, 0)
       );
       return toTextContent({
         ...customer,
@@ -21890,7 +22181,7 @@ function registerCustomerTools(server2) {
       }
       const { data: updated, error: updateError } = await supabase2.from("customers").update(updates).eq("id", params.customerId).select().single();
       if (updateError) {
-        return toErrorContent(`Failed to update customer: ${updateError.message}`);
+        return toErrorContent(sanitizeDbError("Failed to update customer", updateError));
       }
       return toTextContent({
         message: `Customer "${updated.name}" updated`,
@@ -21899,6 +22190,42 @@ function registerCustomerTools(server2) {
       });
     }
   );
+  server2.tool(
+    "kirjapro_lookup_business",
+    "Look up a Finnish company by Y-tunnus (business ID) from PRH (Patent and Registration Office). Returns official company name, address, company form, and registration date. Useful for auto-filling customer details.",
+    {
+      businessId: external_exports.string().regex(/^\d{7}-\d$/).describe('Finnish Y-tunnus (e.g. "1234567-8")')
+    },
+    async (params) => {
+      if (!validateFinnishBusinessId(params.businessId)) {
+        return toErrorContent(
+          `Y-tunnus '${params.businessId}' is invalid (checksum failed). Valid format: 7 digits + hyphen + check digit. Example: 1234567-8.`
+        );
+      }
+      const supabase2 = getSupabase();
+      const result = await invokeEdgeFunction(
+        supabase2,
+        "prh-lookup",
+        { businessId: params.businessId }
+      );
+      if (result.error !== null) {
+        return toErrorContent(result.error);
+      }
+      const company = result.data.company;
+      return toTextContent({
+        business_id: company.businessId,
+        name: company.name,
+        registration_date: company.registrationDate,
+        company_form: company.companyForm,
+        address: company.address,
+        postal_code: company.postalCode,
+        city: company.city,
+        country: company.country,
+        website: company.website,
+        phone: company.phone
+      });
+    }
+  );
 }
 
 // src/tools/reports.ts
@@ -21912,17 +22239,24 @@ function registerReportTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
+      const { data: fiscalYear, error: fyError } = await supabase2.from("fiscal_years").select("start_date, end_date").eq("id", params.fiscalYearId).eq("company_id", companyId2).single();
+      if (fyError || !fiscalYear) {
+        return toErrorContent(
+          `Fiscal year ${params.fiscalYearId} not found. Use kirjapro_list_fiscal_years to find available fiscal years.`
+        );
+      }
+      const JOURNAL_ENTRY_CAP = 5e4;
       const [entriesResult, txCountResult, invoiceResult, bankResult] = await Promise.all([
-        // Revenue & expense totals from journal entries
+        // Revenue & expense totals from journal entries (capped to prevent OOM on large datasets)
         supabase2.from("journal_entries").select(`
             debit_amount, credit_amount,
             account:accounts!inner(account_type),
             transaction:transactions!inner(fiscal_year_id)
-          `).eq("transaction.fiscal_year_id", params.fiscalYearId),
+          `, { count: "exact" }).eq("transaction.fiscal_year_id", params.fiscalYearId).limit(JOURNAL_ENTRY_CAP),
         // Transaction count
         supabase2.from("transactions").select("*", { count: "exact", head: true }).eq("company_id", companyId2).eq("fiscal_year_id", params.fiscalYearId),
-        // Invoice stats
-        supabase2.from("invoices").select("id, status, total, due_date").eq("company_id", companyId2),
+        // Invoice stats scoped to fiscal year date range
+        supabase2.from("invoices").select("id, status, total, due_date").eq("company_id", companyId2).gte("invoice_date", fiscalYear.start_date).lte("invoice_date", fiscalYear.end_date),
         // Bank balances
         supabase2.from("bank_accounts").select("account_name, iban, current_balance").eq("company_id", companyId2).eq("is_active", true)
       ]);
@@ -21952,11 +22286,12 @@ function registerReportTools(server2) {
         }
       }
       const bankAccounts = (bankResult.data || []).map((b) => ({
-        name: b.account_name,
+        name: b.account_name || "Unnamed",
         iban: b.iban,
         balance: b.current_balance || 0
       }));
       const totalBankBalance = bankAccounts.reduce((s, b) => s + b.balance, 0);
+      const entriesCapped = (entriesResult.count || 0) >= JOURNAL_ENTRY_CAP;
       return toTextContent({
         financial_summary: {
           revenue: roundCents(revenue),
@@ -21965,7 +22300,8 @@ function registerReportTools(server2) {
           expenses_formatted: formatCurrency(expenses),
           profit: roundCents(revenue - expenses),
           profit_formatted: formatCurrency(revenue - expenses),
-          transaction_count: txCountResult.count || 0
+          transaction_count: txCountResult.count || 0,
+          ...entriesCapped && { warning: `Results capped at ${JOURNAL_ENTRY_CAP} journal entries. Totals may be approximate.` }
         },
         invoice_stats: invoiceStats,
         bank_summary: {
@@ -21987,13 +22323,14 @@ function registerReportTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       getCompanyId();
-      const { data: entries, error: error2 } = await supabase2.from("journal_entries").select(`
+      const ENTRY_CAP = 5e4;
+      const { data: entries, count: entryCount, error: error2 } = await supabase2.from("journal_entries").select(`
           debit_amount, credit_amount,
           account:accounts!inner(id, account_number, name, account_type),
           transaction:transactions!inner(fiscal_year_id, transaction_date)
-        `).eq("transaction.fiscal_year_id", params.fiscalYearId).gte("transaction.transaction_date", params.dateFrom).lte("transaction.transaction_date", params.dateTo);
+        `, { count: "exact" }).eq("transaction.fiscal_year_id", params.fiscalYearId).gte("transaction.transaction_date", params.dateFrom).lte("transaction.transaction_date", params.dateTo).limit(ENTRY_CAP);
       if (error2) {
-        return toErrorContent(`Failed to generate income statement: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to generate income statement", error2));
       }
       const accountTotals = /* @__PURE__ */ new Map();
       for (const entry of entries || []) {
@@ -22027,6 +22364,7 @@ function registerReportTools(server2) {
           expenseAccounts.push(acc);
         }
       }
+      const capped = (entryCount || 0) >= ENTRY_CAP;
       return toTextContent({
         period: { from: params.dateFrom, to: params.dateTo },
         revenue: {
@@ -22040,7 +22378,8 @@ function registerReportTools(server2) {
           total_formatted: formatCurrency(totalExpenses)
         },
         net_profit: roundCents(totalRevenue - totalExpenses),
-        net_profit_formatted: formatCurrency(totalRevenue - totalExpenses)
+        net_profit_formatted: formatCurrency(totalRevenue - totalExpenses),
+        ...capped && { warning: `Results capped at ${ENTRY_CAP} journal entries. Narrow the date range for accurate totals.` }
       });
     }
   );
@@ -22054,13 +22393,14 @@ function registerReportTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       getCompanyId();
-      const { data: entries, error: error2 } = await supabase2.from("journal_entries").select(`
+      const BS_ENTRY_CAP = 5e4;
+      const { data: entries, count: bsEntryCount, error: error2 } = await supabase2.from("journal_entries").select(`
           debit_amount, credit_amount,
           account:accounts!inner(id, account_number, name, account_type),
           transaction:transactions!inner(fiscal_year_id, transaction_date)
-        `).eq("transaction.fiscal_year_id", params.fiscalYearId).lte("transaction.transaction_date", params.reportDate);
+        `, { count: "exact" }).eq("transaction.fiscal_year_id", params.fiscalYearId).lte("transaction.transaction_date", params.reportDate).limit(BS_ENTRY_CAP);
       if (error2) {
-        return toErrorContent(`Failed to generate balance sheet: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to generate balance sheet", error2));
       }
       const accountTotals = /* @__PURE__ */ new Map();
       for (const entry of entries || []) {
@@ -22105,6 +22445,7 @@ function registerReportTools(server2) {
             break;
         }
       }
+      const bsCapped = (bsEntryCount || 0) >= BS_ENTRY_CAP;
       return toTextContent({
         report_date: params.reportDate,
         assets: {
@@ -22123,7 +22464,8 @@ function registerReportTools(server2) {
           total_formatted: formatCurrency(totalEquity)
         },
         total_liabilities_and_equity: roundCents(totalLiabilities + totalEquity),
-        balanced: Math.abs(totalAssets - (totalLiabilities + totalEquity)) < 0.01
+        balanced: Math.abs(totalAssets - (totalLiabilities + totalEquity)) < 0.01,
+        ...bsCapped && { warning: `Results capped at ${BS_ENTRY_CAP} journal entries. Totals may be approximate.` }
       });
     }
   );
@@ -22136,7 +22478,7 @@ function registerReportTools(server2) {
       const companyId2 = getCompanyId();
       const { data: invoices, error: error2 } = await supabase2.from("invoices").select("id, invoice_number, total, due_date, invoice_date, customers(name)").eq("company_id", companyId2).in("status", ["sent", "overdue"]);
       if (error2) {
-        return toErrorContent(`Failed to get AR aging: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to get AR aging", error2));
       }
       const now = /* @__PURE__ */ new Date();
       const buckets = [
@@ -22208,7 +22550,7 @@ function registerReportTools(server2) {
       }
       const { data: entries, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to get general ledger: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to get general ledger", error2));
       }
       const debitNormal = ["asset", "expense"];
       const isDebitNormal = debitNormal.includes(account.account_type);
@@ -22248,6 +22590,38 @@ function registerReportTools(server2) {
       });
     }
   );
+  server2.tool(
+    "kirjapro_get_alv_summary",
+    "Get VAT (ALV) summary for a date range. Returns output/input VAT breakdown by rate and OmaVero field codes (301-320). For filing deadlines, read kirjapro://compliance/deadlines.",
+    {
+      dateFrom: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Period start date (YYYY-MM-DD)"),
+      dateTo: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Period end date (YYYY-MM-DD)")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data, error: error2 } = await supabase2.rpc("get_alv_summary", {
+        p_company_id: companyId2,
+        p_date_from: params.dateFrom,
+        p_date_to: params.dateTo
+      });
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to get ALV summary", error2));
+      }
+      const result = data;
+      if (!result) {
+        return toTextContent({
+          period: { from: params.dateFrom, to: params.dateTo },
+          message: "No VAT data found for this period."
+        });
+      }
+      return toTextContent({
+        ...result,
+        period: { from: params.dateFrom, to: params.dateTo },
+        net_vat_payable_formatted: formatCurrency(result.net_vat_payable || 0)
+      });
+    }
+  );
 }
 
 // src/tools/banking.ts
@@ -22262,7 +22636,9 @@ function registerBankingTools(server2) {
     async (params) => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data: bankTx, error: btError } = await supabase2.from("bank_transactions").select("id, amount, booking_date, credit_debit, counterparty_name, reference, reconciled_at").eq("id", params.bankTransactionId).eq("company_id", companyId2).single();
+      const { data: bankTx, error: btError } = await supabase2.from("bank_transactions").select(
+        "id, amount, booking_date, credit_debit, counterparty_name, reference, reconciled_at"
+      ).eq("id", params.bankTransactionId).eq("company_id", companyId2).single();
       if (btError || !bankTx) {
         return toErrorContent(
           `Bank transaction ${params.bankTransactionId} not found. Verify the ID and ensure it belongs to your company.`
@@ -22278,58 +22654,58 @@ function registerBankingTools(server2) {
           `Only credit (incoming) bank transactions can be matched to invoices. This is a debit (outgoing) transaction of ${Math.abs(bankTx.amount).toFixed(2)} EUR.`
         );
       }
-      const { data: invoice, error: invError } = await supabase2.from("invoices").select(`
+      const { data: invoice, error: invError } = await supabase2.from("invoices").select(
+        `
           id, invoice_number, total, status,
           invoice_payments ( amount )
-        `).eq("id", params.invoiceId).eq("company_id", companyId2).single();
+        `
+      ).eq("id", params.invoiceId).eq("company_id", companyId2).single();
       if (invError || !invoice) {
         return toErrorContent(
           `Invoice ${params.invoiceId} not found. Use kirjapro_list_invoices to find invoice IDs.`
         );
       }
       if (invoice.status === "paid") {
-        return toErrorContent(`Invoice ${invoice.invoice_number} is already fully paid.`);
+        return toErrorContent(
+          `Invoice ${invoice.invoice_number} is already fully paid.`
+        );
+      }
+      if (invoice.status === "cancelled") {
+        return toErrorContent(
+          `Invoice ${invoice.invoice_number} is cancelled and cannot accept payments.`
+        );
       }
       const paidSoFar = roundCents(
-        (invoice.invoice_payments || []).reduce((s, p) => s + (p.amount || 0), 0)
+        (invoice.invoice_payments || []).reduce(
+          (s, p) => s + (p.amount || 0),
+          0
+        )
       );
       const remaining = roundCents(invoice.total - paidSoFar);
-      const paymentAmount = Math.min(Math.abs(bankTx.amount), remaining);
-      const { data: _payment, error: payError } = await supabase2.from("invoice_payments").insert({
-        invoice_id: params.invoiceId,
-        payment_date: bankTx.booking_date,
-        amount: paymentAmount,
-        payment_method: "bank_transfer",
-        reference: bankTx.reference || null
-      }).select().single();
-      if (payError) {
-        return toErrorContent(`Failed to create payment: ${payError.message}`);
+      const paymentAmount = roundCents(Math.abs(bankTx.amount));
+      if (paymentAmount > remaining + 0.01) {
+        return toErrorContent(
+          `Bank transaction amount ${paymentAmount.toFixed(2)} exceeds remaining invoice balance ${remaining.toFixed(2)} EUR on ${invoice.invoice_number}. Use a smaller matching target or split the payment before reconciling.`
+        );
       }
-      const { data: match, error: _matchError } = await supabase2.from("reconciliation_matches").insert({
-        company_id: companyId2,
-        bank_transaction_id: params.bankTransactionId,
-        match_type: "invoice",
-        matched_invoice_id: params.invoiceId,
-        confidence: 100,
-        match_method: "mcp_manual",
-        status: "confirmed",
-        confirmed_at: (/* @__PURE__ */ new Date()).toISOString()
-      }).select("id").single();
-      await supabase2.from("bank_transactions").update({
-        reconciled_at: (/* @__PURE__ */ new Date()).toISOString(),
-        matched_invoice_id: params.invoiceId,
-        match_confidence: 1,
-        match_method: "mcp_manual",
-        reconciliation_match_id: match?.id || null
-      }).eq("id", params.bankTransactionId);
-      const newPaidTotal = roundCents(paidSoFar + paymentAmount);
-      const newStatus = newPaidTotal >= invoice.total ? "paid" : invoice.status;
-      if (newStatus !== invoice.status) {
-        await supabase2.from("invoices").update({
-          status: newStatus,
-          paid_date: newStatus === "paid" ? bankTx.booking_date : null
-        }).eq("id", params.invoiceId);
+      const { data: matchResult, error: matchError } = await supabase2.rpc(
+        "confirm_reconciliation_match",
+        {
+          p_company_id: companyId2,
+          p_bank_transaction_id: params.bankTransactionId,
+          p_match_type: "invoice",
+          p_matched_invoice_id: params.invoiceId,
+          p_confidence: 100,
+          p_match_method: "mcp_manual"
+        }
+      );
+      if (matchError || !matchResult) {
+        return toErrorContent(
+          matchError ? sanitizeDbError("Failed to confirm reconciliation match", matchError) : "Failed to confirm reconciliation match."
+        );
       }
+      const newPaidTotal = roundCents(paidSoFar + paymentAmount);
+      const newStatus = newPaidTotal >= invoice.total ? "paid" : "partial";
       return toTextContent({
         message: `Bank transaction matched to invoice ${invoice.invoice_number}`,
         payment_amount: paymentAmount,
@@ -22346,9 +22722,11 @@ function registerBankingTools(server2) {
     async () => {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
-      const { data, error: error2 } = await supabase2.from("bank_accounts").select("id, account_name, iban, bic, bank_name, current_balance, available_balance, is_primary, last_sync_at, connection_status").eq("company_id", companyId2).eq("is_active", true).order("is_primary", { ascending: false });
+      const { data, error: error2 } = await supabase2.from("bank_accounts").select(
+        "id, account_name, iban, bic, bank_name, current_balance, available_balance, is_primary, last_sync_at, connection_status"
+      ).eq("company_id", companyId2).eq("is_active", true).order("is_primary", { ascending: false });
       if (error2) {
-        return toErrorContent(`Failed to list bank accounts: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list bank accounts", error2));
       }
       return toTextContent({
         accounts: data || [],
@@ -22401,7 +22779,9 @@ function registerBankingTools(server2) {
       query = query.range(offset, offset + limit - 1);
       const { data, count, error: error2 } = await query;
       if (error2) {
-        return toErrorContent(`Failed to list bank transactions: ${error2.message}`);
+        return toErrorContent(
+          sanitizeDbError("Failed to list bank transactions", error2)
+        );
       }
       return toTextContent(paginate(data || [], count || 0, offset, limit));
     }
@@ -22524,7 +22904,7 @@ function registerFiscalYearTools(server2) {
       const companyId2 = getCompanyId();
       const { data, error: error2 } = await supabase2.from("fiscal_years").select("id, start_date, end_date, is_closed, created_at").eq("company_id", companyId2).order("start_date", { ascending: false });
       if (error2) {
-        return toErrorContent(`Failed to list fiscal years: ${error2.message}`);
+        return toErrorContent(sanitizeDbError("Failed to list fiscal years", error2));
       }
       return toTextContent({
         fiscal_years: data || [],
@@ -22534,137 +22914,1371 @@ function registerFiscalYearTools(server2) {
   );
 }
 
-// src/tools/index.ts
-function registerTools(server2) {
-  registerAccountTools(server2);
-  registerTransactionTools(server2);
-  registerInvoiceTools(server2);
-  registerCustomerTools(server2);
-  registerReportTools(server2);
-  registerBankingTools(server2);
-  registerValidationTools(server2);
-  registerFiscalYearTools(server2);
+// src/tools/templates.ts
+function splitVat(gross, vatRate) {
+  if (vatRate === 0) return { net: roundCents(gross), vat: 0 };
+  const net = roundCents(gross / (1 + vatRate / 100));
+  const vat = roundCents(gross - net);
+  return { net, vat };
+}
+function applyOverrides(entries, overrides) {
+  if (!overrides) return entries;
+  return entries.map((e) => ({
+    ...e,
+    accountNumber: overrides[e.accountNumber] ?? e.accountNumber
+  }));
+}
+function saleCashTemplate(revenueAccount, vatRate) {
+  return (amount, opts) => {
+    const { net, vat } = splitVat(amount, vatRate);
+    const entries = [
+      {
+        accountNumber: "2310",
+        debitAmount: roundCents(amount),
+        creditAmount: 0
+      },
+      { accountNumber: revenueAccount, debitAmount: 0, creditAmount: net }
+    ];
+    if (vat > 0) {
+      entries.push({
+        accountNumber: "4050",
+        debitAmount: 0,
+        creditAmount: vat
+      });
+    }
+    return applyOverrides(entries, opts?.accountOverrides);
+  };
 }
-
-// src/resources/schema.ts
-var CHART_OF_ACCOUNTS = [
-  // Pysyvät vastaavat (Fixed assets)
-  { number: "1000", name: "AINEETTOMAT HY\xD6DYKKEET", type: "asset", header: true },
-  { number: "1010", name: "Perustamismenot", type: "asset" },
-  { number: "1020", name: "Tutkimusmenot", type: "asset" },
-  { number: "1030", name: "Kehitt\xE4mismenot", type: "asset" },
-  { number: "1100", name: "AINEELLISET HY\xD6DYKKEET", type: "asset", header: true },
-  { number: "1110", name: "Maa- ja vesialueet", type: "asset" },
-  { number: "1120", name: "Rakennukset ja rakennelmat", type: "asset" },
-  { number: "1130", name: "Koneet ja kalusto", type: "asset" },
-  { number: "1140", name: "Muut aineelliset hy\xF6dykkeet", type: "asset" },
-  { number: "1200", name: "SIJOITUKSET", type: "asset", header: true },
-  { number: "1210", name: "Osakkeet ja osuudet", type: "asset" },
-  // Vaihtuvat vastaavat (Current assets)
-  { number: "2000", name: "VAIHTO-OMAISUUS", type: "asset", header: true },
-  { number: "2010", name: "Aineet ja tarvikkeet", type: "asset" },
-  { number: "2020", name: "Keskener\xE4iset tuotteet", type: "asset" },
-  { number: "2030", name: "Valmiit tuotteet", type: "asset" },
-  { number: "2100", name: "SAAMISET", type: "asset", header: true },
-  { number: "2110", name: "Myyntisaamiset", type: "asset" },
-  { number: "2120", name: "Lainasaamiset", type: "asset" },
-  { number: "2130", name: "Siirtosaamiset", type: "asset" },
-  { number: "2140", name: "ALV-saamiset", type: "asset" },
-  { number: "2200", name: "RAHOITUSARVOPAPERIT", type: "asset", header: true },
-  { number: "2300", name: "RAHAT JA PANKKISAAMISET", type: "asset", header: true },
-  { number: "2310", name: "Kassa", type: "asset" },
-  { number: "2320", name: "Pankkitili", type: "asset" },
-  // Oma pääoma (Equity)
-  { number: "3000", name: "OMA P\xC4\xC4OMA", type: "equity", header: true },
-  { number: "3010", name: "Osakep\xE4\xE4oma / Perusp\xE4\xE4oma", type: "equity" },
-  { number: "3020", name: "Ylikurssirahasto", type: "equity" },
-  { number: "3030", name: "Sijoitetun vapaan oman p\xE4\xE4oman rahasto (SVOP)", type: "equity" },
-  { number: "3040", name: "Edellisten tilikausien voitto/tappio", type: "equity" },
-  { number: "3050", name: "Tilikauden voitto/tappio", type: "equity" },
-  { number: "3060", name: "Yksityistilit (toiminimi)", type: "equity" },
-  // Vieras pääoma (Liabilities)
-  { number: "4000", name: "VIERAS P\xC4\xC4OMA", type: "liability", header: true },
-  { number: "4010", name: "Pitk\xE4aikaiset lainat", type: "liability" },
-  { number: "4020", name: "Lyhytaikaiset lainat", type: "liability" },
-  { number: "4030", name: "Ostovelat", type: "liability" },
-  { number: "4040", name: "Siirtovelat", type: "liability" },
-  { number: "4050", name: "ALV-velka", type: "liability" },
-  { number: "4060", name: "Ennakonpid\xE4tysvelka", type: "liability" },
-  { number: "4070", name: "Sosiaaliturvamaksuvelka", type: "liability" },
-  { number: "4080", name: "TyEL-velka", type: "liability" },
-  // Tuotot (Revenue)
-  { number: "5000", name: "LIIKEVAIHTO", type: "revenue", header: true },
-  { number: "5010", name: "Myynti 25,5 %", type: "revenue" },
-  { number: "5020", name: "Myynti 13,5 %", type: "revenue" },
-  { number: "5030", name: "Myynti 10 %", type: "revenue" },
-  { number: "5040", name: "Myynti 0 %", type: "revenue" },
-  { number: "5100", name: "LIIKETOIMINNAN MUUT TUOTOT", type: "revenue", header: true },
-  { number: "5110", name: "Vuokratuotot", type: "revenue" },
-  { number: "5120", name: "K\xE4ytt\xF6omaisuuden myyntivoitot", type: "revenue" },
-  // Kulut (Expenses)
-  { number: "6000", name: "MATERIAALIT JA PALVELUT", type: "expense", header: true },
-  { number: "6010", name: "Ostot tilikauden aikana", type: "expense" },
-  { number: "6020", name: "Varastonmuutos", type: "expense" },
-  { number: "6030", name: "Ulkopuoliset palvelut", type: "expense" },
-  { number: "7000", name: "HENKIL\xD6ST\xD6KULUT", type: "expense", header: true },
-  { number: "7010", name: "Palkat ja palkkiot", type: "expense" },
-  { number: "7020", name: "El\xE4kekulut (TyEL)", type: "expense" },
-  { number: "7030", name: "Muut henkil\xF6sivukulut", type: "expense" },
-  { number: "7500", name: "POISTOT JA ARVONALENTUMISET", type: "expense", header: true },
-  { number: "7510", name: "Suunnitelman mukaiset poistot", type: "expense" },
-  { number: "8000", name: "LIIKETOIMINNAN MUUT KULUT", type: "expense", header: true },
-  { number: "8010", name: "Toimitilakulut", type: "expense" },
-  { number: "8020", name: "Ajoneuvokulut", type: "expense" },
-  { number: "8030", name: "Matkakulut", type: "expense" },
-  { number: "8040", name: "Edustuskulut", type: "expense" },
-  { number: "8050", name: "Markkinointikulut", type: "expense" },
-  { number: "8060", name: "Hallintokulut", type: "expense" },
-  { number: "8070", name: "Vakuutukset", type: "expense" },
-  { number: "8080", name: "Tietoliikennekulut", type: "expense" },
-  { number: "8090", name: "Toimistokulut", type: "expense" },
-  { number: "8400", name: "RAHOITUSTUOTOT JA -KULUT", type: "expense", header: true },
-  { number: "8410", name: "Korkotuotot", type: "revenue" },
-  { number: "8420", name: "Korkokulut", type: "expense" },
-  { number: "8430", name: "Muut rahoitustuotot", type: "revenue" },
-  { number: "8440", name: "Muut rahoituskulut", type: "expense" },
-  { number: "9000", name: "TULOVEROT", type: "expense", header: true },
-  { number: "9010", name: "Tilikauden tuloverot", type: "expense" },
-  { number: "9020", name: "Laskennalliset verot", type: "expense" }
-];
-var VAT_RATES = [
-  { rate: 25.5, label: "Yleinen verokanta", description: "Standard rate for most goods and services" },
-  { rate: 13.5, label: "Elintarvikkeet, ravintolat", description: "Food, restaurant services (lowered from 14% Jan 2025)" },
-  { rate: 10, label: "Kirjat, l\xE4\xE4kkeet, liikunta", description: "Books, medicines, sports services, accommodation" },
-  { rate: 0, label: "Veroton", description: "Tax-exempt: exports, international trade, certain financial services" }
-];
-function registerSchemaResources(server2) {
-  server2.resource(
-    "chart-of-accounts",
-    "kirjapro://accounts/chart",
-    {
-      description: "Finnish standard chart of accounts (YSE 2017). Reference data for account numbers, names, and types.",
-      mimeType: "application/json"
-    },
-    async (uri) => ({
-      contents: [{
-        uri: uri.href,
-        mimeType: "application/json",
-        text: JSON.stringify(CHART_OF_ACCOUNTS, null, 2)
-      }]
-    })
-  );
+function saleBankTemplate(revenueAccount, vatRate) {
+  return (amount, opts) => {
+    const { net, vat } = splitVat(amount, vatRate);
+    const entries = [
+      {
+        accountNumber: "2320",
+        debitAmount: roundCents(amount),
+        creditAmount: 0
+      },
+      { accountNumber: revenueAccount, debitAmount: 0, creditAmount: net }
+    ];
+    if (vat > 0) {
+      entries.push({
+        accountNumber: "4050",
+        debitAmount: 0,
+        creditAmount: vat
+      });
+    }
+    return applyOverrides(entries, opts?.accountOverrides);
+  };
+}
+var TEMPLATES = [
+  // Cash sales
+  {
+    id: "cash_sale_25",
+    description: "K\xE4teismyynti ALV 25,5%",
+    vatRate: 25.5,
+    expand: saleCashTemplate("5010", 25.5)
+  },
+  {
+    id: "cash_sale_14",
+    description: "K\xE4teismyynti ALV 13,5%",
+    vatRate: 13.5,
+    expand: saleCashTemplate("5020", 13.5)
+  },
+  {
+    id: "cash_sale_10",
+    description: "K\xE4teismyynti ALV 10%",
+    vatRate: 10,
+    expand: saleCashTemplate("5030", 10)
+  },
+  {
+    id: "cash_sale_0",
+    description: "K\xE4teismyynti ALV 0%",
+    vatRate: 0,
+    expand: saleCashTemplate("5040", 0)
+  },
+  // Bank sales
+  {
+    id: "bank_sale_25",
+    description: "Pankkimyynti ALV 25,5%",
+    vatRate: 25.5,
+    expand: saleBankTemplate("5010", 25.5)
+  },
+  {
+    id: "bank_sale_14",
+    description: "Pankkimyynti ALV 13,5%",
+    vatRate: 13.5,
+    expand: saleBankTemplate("5020", 13.5)
+  },
+  {
+    id: "bank_sale_10",
+    description: "Pankkimyynti ALV 10%",
+    vatRate: 10,
+    expand: saleBankTemplate("5030", 10)
+  },
+  // Invoice sale
+  {
+    id: "invoice_sale_25",
+    description: "Laskumyynti ALV 25,5% (myyntisaamiset)",
+    vatRate: 25.5,
+    expand: (amount, opts) => {
+      const { net, vat } = splitVat(amount, 25.5);
+      return applyOverrides(
+        [
+          {
+            accountNumber: "2110",
+            debitAmount: roundCents(amount),
+            creditAmount: 0
+          },
+          { accountNumber: "5010", debitAmount: 0, creditAmount: net },
+          { accountNumber: "4050", debitAmount: 0, creditAmount: vat }
+        ],
+        opts?.accountOverrides
+      );
+    }
+  },
+  // Purchase expenses
+  {
+    id: "purchase_expense",
+    description: "Osto ALV 25,5% (pankkitililt\xE4)",
+    vatRate: 25.5,
+    expand: (amount, opts) => {
+      const { net, vat } = splitVat(amount, 25.5);
+      return applyOverrides(
+        [
+          { accountNumber: "6010", debitAmount: net, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: vat, creditAmount: 0 },
+          {
+            accountNumber: "2320",
+            debitAmount: 0,
+            creditAmount: roundCents(amount)
+          }
+        ],
+        opts?.accountOverrides
+      );
+    }
+  },
+  {
+    id: "service_expense",
+    description: "Ulkopuolinen palvelu ALV 25,5%",
+    vatRate: 25.5,
+    expand: (amount, opts) => {
+      const { net, vat } = splitVat(amount, 25.5);
+      return applyOverrides(
+        [
+          { accountNumber: "6030", debitAmount: net, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: vat, creditAmount: 0 },
+          {
+            accountNumber: "2320",
+            debitAmount: 0,
+            creditAmount: roundCents(amount)
+          }
+        ],
+        opts?.accountOverrides
+      );
+    }
+  },
+  // Rent (no VAT)
+  {
+    id: "rent_payment",
+    description: "Vuokranmaksu (pankkitililt\xE4)",
+    vatRate: null,
+    expand: (amount, opts) => applyOverrides(
+      [
+        {
+          accountNumber: "8010",
+          debitAmount: roundCents(amount),
+          creditAmount: 0
+        },
+        {
+          accountNumber: "2320",
+          debitAmount: 0,
+          creditAmount: roundCents(amount)
+        }
+      ],
+      opts?.accountOverrides
+    )
+  },
+  // Salary
+  {
+    id: "salary_payment",
+    description: "Palkanmaksu (bruttopalkka, ennakonpid\xE4tys, TyEL)",
+    vatRate: null,
+    expand: (amount, opts) => {
+      const gross = roundCents(amount);
+      const withholdingRate = opts?.withholdingRate ?? 20;
+      const tyelEmployeeRate = opts?.tyelRate ?? 7.3;
+      const tyelEmployerRate = 17.55;
+      const withholding = roundCents(gross * withholdingRate / 100);
+      const tyelEmployee = roundCents(gross * tyelEmployeeRate / 100);
+      const tyelEmployer = roundCents(gross * tyelEmployerRate / 100);
+      const netPay = roundCents(gross - withholding - tyelEmployee);
+      return applyOverrides(
+        [
+          { accountNumber: "7010", debitAmount: gross, creditAmount: 0 },
+          { accountNumber: "7020", debitAmount: tyelEmployer, creditAmount: 0 },
+          { accountNumber: "2320", debitAmount: 0, creditAmount: netPay },
+          { accountNumber: "4060", debitAmount: 0, creditAmount: withholding },
+          {
+            accountNumber: "4080",
+            debitAmount: 0,
+            creditAmount: roundCents(tyelEmployee + tyelEmployer)
+          }
+        ],
+        opts?.accountOverrides
+      );
+    }
+  },
+  // Bank transfer
+  {
+    id: "bank_transfer",
+    description: "Tilisiirto kassasta pankkitilille",
+    vatRate: null,
+    expand: (amount, opts) => applyOverrides(
+      [
+        {
+          accountNumber: "2320",
+          debitAmount: roundCents(amount),
+          creditAmount: 0
+        },
+        {
+          accountNumber: "2310",
+          debitAmount: 0,
+          creditAmount: roundCents(amount)
+        }
+      ],
+      opts?.accountOverrides
+    )
+  }
+];
+var TEMPLATE_MAP = new Map(TEMPLATES.map((t) => [t.id, t]));
+function expandTemplate(templateId, amount, opts) {
+  const template = TEMPLATE_MAP.get(templateId);
+  if (!template) {
+    return {
+      error: `Unknown template "${templateId}". Use kirjapro_list_templates to see available templates.`
+    };
+  }
+  if (amount <= 0) {
+    return { error: "Amount must be positive." };
+  }
+  const entries = template.expand(amount, opts);
+  return { entries };
+}
+async function resolveAndCreate(params) {
+  const supabase2 = getSupabase();
+  const companyId2 = getCompanyId();
+  let fiscalYearId = params.fiscalYearId;
+  if (!fiscalYearId) {
+    const resolved = await resolveOpenFiscalYear(supabase2, companyId2);
+    if ("isError" in resolved) return resolved;
+    fiscalYearId = resolved.id;
+  }
+  const { data: fy, error: fyError } = await supabase2.from("fiscal_years").select("id, is_closed, start_date, end_date").eq("id", fiscalYearId).eq("company_id", companyId2).single();
+  if (fyError || !fy) {
+    return toErrorContent(
+      `Fiscal year ${fiscalYearId} not found. Use kirjapro_get_dashboard or read kirjapro://fiscal-years resource.`
+    );
+  }
+  if (fy.is_closed) {
+    return toErrorContent(
+      `Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`
+    );
+  }
+  if (params.transactionDate < fy.start_date || params.transactionDate > fy.end_date) {
+    return toErrorContent(
+      `Transaction date ${params.transactionDate} outside fiscal year (${fy.start_date} to ${fy.end_date}).`
+    );
+  }
+  const accountNumbers = [
+    ...new Set(params.entries.map((e) => e.accountNumber))
+  ];
+  const { data: accounts, error: accError } = await supabase2.from("accounts").select("id, account_number").eq("company_id", companyId2).in("account_number", accountNumbers);
+  if (accError) {
+    return toErrorContent(`Failed to resolve accounts: ${accError.message}`);
+  }
+  const accountMap = new Map(
+    (accounts || []).map((a) => [a.account_number, a.id])
+  );
+  const missing = accountNumbers.filter((n) => !accountMap.has(n));
+  if (missing.length > 0) {
+    return toErrorContent(
+      `Account numbers not found: ${missing.join(", ")}. Use kirjapro_list_accounts to see available accounts.`
+    );
+  }
+  const totalDebit = roundCents(
+    params.entries.reduce((s, e) => s + e.debitAmount, 0)
+  );
+  const totalCredit = roundCents(
+    params.entries.reduce((s, e) => s + e.creditAmount, 0)
+  );
+  if (Math.abs(totalDebit - totalCredit) >= 0.01) {
+    return toErrorContent(
+      `Template produced unbalanced entries: debits ${totalDebit.toFixed(2)} != credits ${totalCredit.toFixed(2)}.`
+    );
+  }
+  const journalEntries = params.entries.map((e) => ({
+    account_id: accountMap.get(e.accountNumber),
+    debit_amount: e.debitAmount,
+    credit_amount: e.creditAmount
+  }));
+  const { data: transactionId, error: txError } = await supabase2.rpc(
+    "create_transaction_with_entries",
+    {
+      p_company_id: companyId2,
+      p_fiscal_year_id: fiscalYearId,
+      p_transaction_date: params.transactionDate,
+      p_description: params.description,
+      p_document_number: params.documentNumber || "",
+      p_entries: journalEntries
+    }
+  );
+  if (txError || !transactionId) {
+    return toErrorContent(
+      txError ? sanitizeDbError("Failed to create transaction", txError) : "Failed to create transaction: no ID returned."
+    );
+  }
+  return { id: transactionId };
+}
+function registerTemplateTools(server2) {
+  server2.tool(
+    "kirjapro_list_templates",
+    "List available transaction templates. Templates handle double-entry balancing and VAT splitting automatically.",
+    {},
+    async () => {
+      const list = TEMPLATES.map((t) => ({
+        id: t.id,
+        description: t.description,
+        vatRate: t.vatRate
+      }));
+      return toTextContent({ templates: list });
+    }
+  );
+  server2.tool(
+    "kirjapro_create_from_template",
+    'Create a transaction from a template. Use kirjapro_list_templates for available templates. accountOverrides swaps default accounts (e.g. {"2320": "2330"}).',
+    {
+      template: external_exports.string().describe('Template ID (e.g. "cash_sale_25", "purchase_expense")'),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      transactionDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Transaction date (YYYY-MM-DD)"),
+      amount: external_exports.number().positive().describe("Gross amount in EUR"),
+      description: external_exports.string().min(1).max(500).describe("Transaction description"),
+      documentNumber: external_exports.string().optional().describe("Document/receipt number"),
+      withholdingRate: external_exports.number().min(0).max(100).optional().describe("Withholding tax % for salary_payment (default 20)"),
+      tyelRate: external_exports.number().min(0).max(100).optional().describe("TyEL employee % for salary_payment (default 7.30)"),
+      accountOverrides: external_exports.record(external_exports.string(), external_exports.string()).optional().describe('Account number swaps, e.g. {"2320": "2330"}')
+    },
+    async (params) => {
+      const result = expandTemplate(params.template, params.amount, {
+        withholdingRate: params.withholdingRate,
+        tyelRate: params.tyelRate,
+        accountOverrides: params.accountOverrides
+      });
+      if ("error" in result) {
+        return toErrorContent(result.error);
+      }
+      const createResult = await resolveAndCreate({
+        fiscalYearId: params.fiscalYearId,
+        transactionDate: params.transactionDate,
+        description: params.description,
+        documentNumber: params.documentNumber,
+        entries: result.entries
+      });
+      if ("isError" in createResult) {
+        return createResult;
+      }
+      return toTextContent({
+        message: "Transaction created from template",
+        template: params.template,
+        transaction_id: createResult.id,
+        entries: result.entries
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_create_from_template_batch",
+    "Create multiple transactions from templates in one call (up to 50). Each is validated independently \u2014 valid ones succeed even if others fail.",
+    {
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      transactions: external_exports.array(
+        external_exports.object({
+          template: external_exports.string().describe("Template ID"),
+          transactionDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Date (YYYY-MM-DD)"),
+          amount: external_exports.number().positive().describe("Gross amount in EUR"),
+          description: external_exports.string().min(1).max(500),
+          documentNumber: external_exports.string().optional(),
+          withholdingRate: external_exports.number().min(0).max(100).optional(),
+          tyelRate: external_exports.number().min(0).max(100).optional(),
+          accountOverrides: external_exports.record(external_exports.string(), external_exports.string()).optional()
+        })
+      ).min(1).max(50).describe("Array of template transactions to create (max 50)")
+    },
+    async (params) => {
+      const created = [];
+      const failed = [];
+      for (let i = 0; i < params.transactions.length; i++) {
+        const tx = params.transactions[i];
+        const result = expandTemplate(tx.template, tx.amount, {
+          withholdingRate: tx.withholdingRate,
+          tyelRate: tx.tyelRate,
+          accountOverrides: tx.accountOverrides
+        });
+        if ("error" in result) {
+          failed.push({ index: i, error: result.error });
+          continue;
+        }
+        const createResult = await resolveAndCreate({
+          fiscalYearId: params.fiscalYearId,
+          transactionDate: tx.transactionDate,
+          description: tx.description,
+          documentNumber: tx.documentNumber,
+          entries: result.entries
+        });
+        if ("isError" in createResult) {
+          failed.push({ index: i, error: createResult.content[0].text });
+          continue;
+        }
+        created.push({
+          id: createResult.id,
+          description: tx.description,
+          date: tx.transactionDate
+        });
+      }
+      return toTextContent({
+        created_count: created.length,
+        failed_count: failed.length,
+        created,
+        failed
+      });
+    }
+  );
+}
+
+// src/tools/bookings.ts
+var DEFAULTS = {
+  tyelEmployee: 7.3,
+  tyelEmployer: 17.55,
+  sotu: 1.91,
+  ttvEmployer: 0.31,
+  ttvEmployee: 0.89
+};
+function registerBookingTools(server2) {
+  server2.tool(
+    "kirjapro_book_purchase",
+    "Book a purchase (osto) with automatic VAT splitting. Supports reverse charge (AVL 9\xA7) and entertainment (edustus, AVL 114\xA7). Rate rules: food/restaurants 13.5%, insurance 0% (exempt), alcohol 25.5%.",
+    {
+      amount: external_exports.number().positive().describe("Gross EUR amount (VAT-inclusive)"),
+      description: external_exports.string().min(1).max(500).describe("Transaction description"),
+      date: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Transaction date (YYYY-MM-DD)"),
+      vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).describe("Finnish VAT rate"),
+      expenseAccount: external_exports.string().describe('Expense account number (e.g. "8080")'),
+      reverseCharge: external_exports.boolean().default(false).describe("EU reverse charge: D expense + D 2140 + C 4050 + C bank"),
+      edustus: external_exports.boolean().default(false).describe("Entertainment expense (AVL 114\xA7): 0% VAT deduction, full gross to expense"),
+      paymentAccount: external_exports.string().default("2320").describe('Payment account (default "2320" Pankkitili)'),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      documentNumber: external_exports.string().optional().describe("Document/receipt number")
+    },
+    async (params) => {
+      const rate = Number.parseFloat(params.vatRate);
+      const gross = roundCents(params.amount);
+      let entries;
+      if (params.edustus) {
+        entries = [
+          { accountNumber: params.expenseAccount, debitAmount: gross, creditAmount: 0 },
+          { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: gross }
+        ];
+      } else if (params.reverseCharge) {
+        const vat = roundCents(gross * rate / 100);
+        entries = [
+          { accountNumber: params.expenseAccount, debitAmount: gross, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: vat, creditAmount: 0 },
+          // ALV-saamiset (input)
+          { accountNumber: "4050", debitAmount: 0, creditAmount: vat },
+          // ALV-velka (output)
+          { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: gross }
+        ];
+      } else if (rate === 0) {
+        entries = [
+          { accountNumber: params.expenseAccount, debitAmount: gross, creditAmount: 0 },
+          { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: gross }
+        ];
+      } else {
+        const { net, vat } = splitVat(gross, rate);
+        entries = [
+          { accountNumber: params.expenseAccount, debitAmount: net, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: vat, creditAmount: 0 },
+          { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: gross }
+        ];
+      }
+      const result = await resolveAndCreate({
+        fiscalYearId: params.fiscalYearId,
+        transactionDate: params.date,
+        description: params.description,
+        documentNumber: params.documentNumber,
+        entries
+      });
+      if ("isError" in result) return result;
+      return toTextContent({
+        message: "Purchase booked",
+        transaction_id: result.id,
+        entries
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_book_salary",
+    "Book salary payment (palkanmaksu). Creates salary + employer cost transactions with withholding, TyEL, TTV, sotu. Default rates are 2026 Finnish social insurance rates.",
+    {
+      grossSalary: external_exports.number().positive().describe("Gross salary EUR"),
+      employeeName: external_exports.string().min(1).describe("Employee name (for description)"),
+      date: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Payment date (YYYY-MM-DD)"),
+      withholdingRate: external_exports.number().min(0).max(100).describe("Withholding tax % (ennakonpid\xE4tys)"),
+      tyelEmployeeRate: external_exports.number().min(0).max(100).default(DEFAULTS.tyelEmployee).describe("TyEL employee % (default 7.30)"),
+      tyelEmployerRate: external_exports.number().min(0).max(100).default(DEFAULTS.tyelEmployer).describe("TyEL employer % (default 17.55)"),
+      sotuRate: external_exports.number().min(0).max(100).default(DEFAULTS.sotu).describe("Sairausvakuutusmaksu employer % (default 1.91)"),
+      ttvEmployerRate: external_exports.number().min(0).max(100).default(DEFAULTS.ttvEmployer).describe("Ty\xF6tt\xF6myysvakuutus employer % (default 0.31)"),
+      ttvEmployeeRate: external_exports.number().min(0).max(100).default(DEFAULTS.ttvEmployee).describe("Ty\xF6tt\xF6myysvakuutus employee % (default 0.89)"),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      paymentAccount: external_exports.string().default("2320").describe('Bank account (default "2320")')
+    },
+    async (params) => {
+      const gross = roundCents(params.grossSalary);
+      const withholding = roundCents(gross * params.withholdingRate / 100);
+      const tyelEmployee = roundCents(gross * params.tyelEmployeeRate / 100);
+      const ttvEmployee = roundCents(gross * params.ttvEmployeeRate / 100);
+      const netPay = roundCents(gross - withholding - tyelEmployee - ttvEmployee);
+      const tyelEmployer = roundCents(gross * params.tyelEmployerRate / 100);
+      const sotuAmount = roundCents(gross * params.sotuRate / 100);
+      const ttvEmployer = roundCents(gross * params.ttvEmployerRate / 100);
+      if (netPay < 0) {
+        return toErrorContent(
+          `Net pay is negative (${netPay.toFixed(2)}). Check withholding rate (${params.withholdingRate}%) and deduction rates.`
+        );
+      }
+      const salaryEntries = [
+        { accountNumber: "7010", debitAmount: gross, creditAmount: 0 },
+        { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: netPay },
+        { accountNumber: "4060", debitAmount: 0, creditAmount: withholding },
+        { accountNumber: "4080", debitAmount: 0, creditAmount: tyelEmployee },
+        { accountNumber: "4070", debitAmount: 0, creditAmount: ttvEmployee }
+      ];
+      const salaryResult = await resolveAndCreate({
+        fiscalYearId: params.fiscalYearId,
+        transactionDate: params.date,
+        description: `Palkka ${params.employeeName}`,
+        entries: salaryEntries
+      });
+      if ("isError" in salaryResult) return salaryResult;
+      const employerSotuTtv = roundCents(sotuAmount + ttvEmployer);
+      const employerEntries = [
+        { accountNumber: "7020", debitAmount: tyelEmployer, creditAmount: 0 },
+        { accountNumber: "7030", debitAmount: employerSotuTtv, creditAmount: 0 },
+        { accountNumber: "4080", debitAmount: 0, creditAmount: tyelEmployer },
+        { accountNumber: "4070", debitAmount: 0, creditAmount: employerSotuTtv }
+      ];
+      const employerResult = await resolveAndCreate({
+        fiscalYearId: params.fiscalYearId,
+        transactionDate: params.date,
+        description: `Sivukulut ${params.employeeName}`,
+        entries: employerEntries
+      });
+      if ("isError" in employerResult) return employerResult;
+      return toTextContent({
+        message: "Salary booked (2 transactions)",
+        salary_transaction_id: salaryResult.id,
+        employer_costs_transaction_id: employerResult.id,
+        summary: {
+          gross,
+          withholding,
+          tyelEmployee,
+          ttvEmployee,
+          netPay,
+          tyelEmployer,
+          sotu: sotuAmount,
+          ttvEmployer,
+          totalEmployerCost: roundCents(gross + tyelEmployer + sotuAmount + ttvEmployer)
+        }
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_book_vat_settlement",
+    "Book ALV-tilitys (VAT settlement) for a month. Calculates net from ALV accounts (2140/4050) and creates settlement. Default date: 12th of month+1.",
+    {
+      month: external_exports.string().regex(/^\d{4}-\d{2}$/).describe("Settlement month (YYYY-MM)"),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      settlementDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Settlement date (default: 12th of month+1)"),
+      paymentAccount: external_exports.string().default("2320").describe('Bank account (default "2320")')
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      let fiscalYearId = params.fiscalYearId;
+      if (!fiscalYearId) {
+        const resolved = await resolveOpenFiscalYear(supabase2, companyId2);
+        if ("isError" in resolved) return resolved;
+        fiscalYearId = resolved.id;
+      }
+      const [year, monthStr] = params.month.split("-");
+      const monthStart = `${params.month}-01`;
+      const monthNum = Number.parseInt(monthStr, 10);
+      const nextMonth = monthNum === 12 ? `${Number.parseInt(year, 10) + 1}-01` : `${year}-${String(monthNum + 1).padStart(2, "0")}`;
+      const monthEnd = /* @__PURE__ */ new Date(`${nextMonth}-01`);
+      monthEnd.setDate(monthEnd.getDate() - 1);
+      const monthEndStr = monthEnd.toISOString().slice(0, 10);
+      let settlementDate = params.settlementDate ?? `${nextMonth}-12`;
+      const { data: fy } = await supabase2.from("fiscal_years").select("start_date, end_date").eq("id", fiscalYearId).eq("company_id", companyId2).single();
+      if (fy && settlementDate > fy.end_date) {
+        settlementDate = fy.end_date;
+      }
+      const { data: alvSaamiset, error: err1 } = await supabase2.from("journal_entries").select("debit_amount, credit_amount, accounts!inner(account_number), transactions!inner(transaction_date, company_id, fiscal_year_id)").eq("accounts.account_number", "2140").eq("transactions.company_id", companyId2).eq("transactions.fiscal_year_id", fiscalYearId).gte("transactions.transaction_date", monthStart).lte("transactions.transaction_date", monthEndStr);
+      if (err1) {
+        return toErrorContent(`Failed to query ALV-saamiset: ${err1.message}`);
+      }
+      const { data: alvVelka, error: err2 } = await supabase2.from("journal_entries").select("debit_amount, credit_amount, accounts!inner(account_number), transactions!inner(transaction_date, company_id, fiscal_year_id)").eq("accounts.account_number", "4050").eq("transactions.company_id", companyId2).eq("transactions.fiscal_year_id", fiscalYearId).gte("transactions.transaction_date", monthStart).lte("transactions.transaction_date", monthEndStr);
+      if (err2) {
+        return toErrorContent(`Failed to query ALV-velka: ${err2.message}`);
+      }
+      const saamisetBalance = roundCents(
+        (alvSaamiset || []).reduce((s, e) => s + (e.debit_amount || 0) - (e.credit_amount || 0), 0)
+      );
+      const velkaBalance = roundCents(
+        (alvVelka || []).reduce((s, e) => s + (e.credit_amount || 0) - (e.debit_amount || 0), 0)
+      );
+      if (saamisetBalance === 0 && velkaBalance === 0) {
+        return toTextContent({
+          message: `No VAT entries found for ${params.month}. Nothing to settle.`,
+          alv_saamiset: 0,
+          alv_velka: 0
+        });
+      }
+      const netVat = roundCents(velkaBalance - saamisetBalance);
+      let entries;
+      if (netVat > 0) {
+        entries = [
+          { accountNumber: "4050", debitAmount: velkaBalance, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: 0, creditAmount: saamisetBalance },
+          { accountNumber: params.paymentAccount, debitAmount: 0, creditAmount: netVat }
+        ];
+      } else if (netVat < 0) {
+        const refund = Math.abs(netVat);
+        entries = [
+          { accountNumber: "4050", debitAmount: velkaBalance, creditAmount: 0 },
+          { accountNumber: params.paymentAccount, debitAmount: refund, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: 0, creditAmount: saamisetBalance }
+        ];
+      } else {
+        entries = [
+          { accountNumber: "4050", debitAmount: velkaBalance, creditAmount: 0 },
+          { accountNumber: "2140", debitAmount: 0, creditAmount: saamisetBalance }
+        ];
+      }
+      const result = await resolveAndCreate({
+        fiscalYearId,
+        transactionDate: settlementDate,
+        description: `ALV-tilitys ${params.month}`,
+        entries
+      });
+      if ("isError" in result) return result;
+      return toTextContent({
+        message: `VAT settlement booked for ${params.month}`,
+        transaction_id: result.id,
+        alv_saamiset: saamisetBalance,
+        alv_velka: velkaBalance,
+        net_vat: netVat,
+        direction: netVat > 0 ? "pay" : netVat < 0 ? "refund" : "zero"
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_book_sale",
+    "Book a sale (myynti) with automatic VAT splitting. Payment types: invoice (default, D Myyntisaamiset), cash (D bank), prepaid.",
+    {
+      amount: external_exports.number().positive().describe("Gross EUR amount (VAT-inclusive)"),
+      description: external_exports.string().min(1).max(500).describe('Transaction description (e.g. "Konsultointi Acme Oy, 40h \xD7 95 \u20AC")'),
+      date: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("Transaction date (YYYY-MM-DD)"),
+      vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).describe("Finnish VAT rate"),
+      revenueAccount: external_exports.string().default("3000").describe('Revenue account number (default "3000" Myynti)'),
+      paymentType: external_exports.enum(["invoice", "cash", "prepaid"]).default("invoice").describe("invoice = receivable (1700), cash/prepaid = bank payment (2320)"),
+      paymentAccount: external_exports.string().default("2320").describe('Bank account for cash/prepaid payments (default "2320")'),
+      fiscalYearId: external_exports.string().uuid().optional().describe("Fiscal year UUID (auto-resolved if omitted)"),
+      documentNumber: external_exports.string().optional().describe("Document/receipt number")
+    },
+    async (params) => {
+      const rate = Number.parseFloat(params.vatRate);
+      const gross = roundCents(params.amount);
+      let entries;
+      const debitAccount = params.paymentType === "invoice" ? "1700" : params.paymentAccount;
+      if (rate === 0) {
+        entries = [
+          { accountNumber: debitAccount, debitAmount: gross, creditAmount: 0 },
+          { accountNumber: params.revenueAccount, debitAmount: 0, creditAmount: gross }
+        ];
+      } else {
+        const { net: net2, vat: vat2 } = splitVat(gross, rate);
+        entries = [
+          { accountNumber: debitAccount, debitAmount: gross, creditAmount: 0 },
+          { accountNumber: params.revenueAccount, debitAmount: 0, creditAmount: net2 },
+          { accountNumber: "4050", debitAmount: 0, creditAmount: vat2 }
+        ];
+      }
+      const result = await resolveAndCreate({
+        fiscalYearId: params.fiscalYearId,
+        transactionDate: params.date,
+        description: params.description,
+        documentNumber: params.documentNumber,
+        entries
+      });
+      if ("isError" in result) return result;
+      const { net, vat } = rate > 0 ? splitVat(gross, rate) : { net: gross, vat: 0 };
+      return toTextContent({
+        message: "Sale booked",
+        transaction_id: result.id,
+        gross,
+        net,
+        vat,
+        vat_rate: `${params.vatRate} %`,
+        payment_type: params.paymentType,
+        debit_account: debitAccount,
+        revenue_account: params.revenueAccount,
+        entries
+      });
+    }
+  );
+}
+
+// src/tools/offers.ts
+function generateOfferNumber(lastNumber, type) {
+  const prefix = type === "sopimus" ? "SOP" : "TAR";
+  if (!lastNumber) return `${prefix}00001`;
+  const numPart = lastNumber.replace(/\D/g, "");
+  const next = parseInt(numPart || "0") + 1;
+  return `${prefix}${next.toString().padStart(5, "0")}`;
+}
+function registerOfferTools(server2) {
+  server2.tool(
+    "kirjapro_list_offers",
+    "List offers/contracts with customer names. Filter by status (draft, sent, viewed, accepted, rejected, expired) and type (tarjous, sopimus).",
+    {
+      status: external_exports.enum(["draft", "sent", "viewed", "accepted", "rejected", "expired"]).optional().describe("Filter by offer status"),
+      type: external_exports.enum(["tarjous", "sopimus"]).optional().describe("Filter by type (tarjous = offer, sopimus = contract)"),
+      limit: external_exports.number().min(1).max(200).default(50).describe("Max results (default 50)"),
+      offset: external_exports.number().min(0).default(0).describe("Skip first N results")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { limit, offset } = clampPagination(params.limit, params.offset);
+      let query = supabase2.from("offers").select(`
+          id, offer_number, type, title, status, subtotal, vat_total, total,
+          valid_from, valid_until, invoice_id, created_at,
+          customers ( name, business_id )
+        `, { count: "exact" }).eq("company_id", companyId2).order("created_at", { ascending: false });
+      if (params.status) {
+        query = query.eq("status", params.status);
+      }
+      if (params.type) {
+        query = query.eq("type", params.type);
+      }
+      query = query.range(offset, offset + limit - 1);
+      const { data, count, error: error2 } = await query;
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to list offers", error2));
+      }
+      return toTextContent(paginate(data || [], count || 0, offset, limit));
+    }
+  );
+  server2.tool(
+    "kirjapro_get_offer",
+    "Get a single offer/contract with full detail: customer info, line items, events, and VAT breakdown.",
+    {
+      offerId: external_exports.string().uuid().describe("Offer UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: offer, error: error2 } = await supabase2.from("offers").select(`
+          id, offer_number, type, title, content, status,
+          subtotal, vat_total, total, notes, valid_from, valid_until,
+          invoice_id, sent_at, created_at,
+          customers ( id, name, business_id, email, address, postal_code, city ),
+          offer_lines ( id, line_number, description, quantity, unit, unit_price, vat_rate, subtotal, vat_amount, total ),
+          offer_events ( id, event_type, created_at, metadata )
+        `).eq("id", params.offerId).eq("company_id", companyId2).single();
+      if (error2 || !offer) {
+        return toErrorContent(
+          `Offer ${params.offerId} not found. Use kirjapro_list_offers to find offer IDs.`
+        );
+      }
+      return toTextContent(offer);
+    }
+  );
+  server2.tool(
+    "kirjapro_create_offer",
+    "Create a new offer (tarjous) or contract (sopimus) with line items. Automatically generates offer number and calculates VAT. Returns the created offer.",
+    {
+      type: external_exports.enum(["tarjous", "sopimus"]).default("tarjous").describe("Type: tarjous (offer) or sopimus (contract)"),
+      title: external_exports.string().min(1).describe("Offer title"),
+      customerId: external_exports.string().uuid().optional().describe("Customer UUID (optional)"),
+      content: external_exports.string().optional().describe("Free-text content/description"),
+      validFrom: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Valid from date (YYYY-MM-DD)"),
+      validUntil: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Valid until date (YYYY-MM-DD)"),
+      notes: external_exports.string().optional().describe("Internal notes (not visible to customer)"),
+      lines: external_exports.array(external_exports.object({
+        description: external_exports.string().min(1).describe("Line item description"),
+        quantity: external_exports.number().min(0).describe("Quantity"),
+        unit: external_exports.string().default("kpl").describe("Unit (kpl, h, kk, etc.)"),
+        unitPrice: external_exports.number().describe("Unit price in EUR (excl. VAT)"),
+        vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).default("25.5").describe("VAT rate")
+      })).min(1).describe("Line items")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      if (params.customerId) {
+        const { data: customer, error: custError } = await supabase2.from("customers").select("id, name").eq("id", params.customerId).eq("company_id", companyId2).single();
+        if (custError || !customer) {
+          return toErrorContent(
+            `Customer ${params.customerId} not found. Use kirjapro_list_customers to find customer IDs.`
+          );
+        }
+      }
+      const { data: lastOffer } = await supabase2.from("offers").select("offer_number").eq("company_id", companyId2).eq("type", params.type).order("created_at", { ascending: false }).limit(1).maybeSingle();
+      const offerNumber = generateOfferNumber(lastOffer?.offer_number || null, params.type);
+      const calculatedLines = params.lines.map((line, i) => {
+        const vatRate = parseFloat(line.vatRate);
+        const subtotal2 = roundCents(line.quantity * line.unitPrice);
+        const vatAmount = roundCents(subtotal2 * (vatRate / 100));
+        const total2 = roundCents(subtotal2 + vatAmount);
+        return {
+          line_number: i + 1,
+          description: line.description,
+          quantity: line.quantity,
+          unit: line.unit,
+          unit_price: line.unitPrice,
+          vat_rate: vatRate,
+          subtotal: subtotal2,
+          vat_amount: vatAmount,
+          total: total2
+        };
+      });
+      const subtotal = roundCents(calculatedLines.reduce((s, l) => s + l.subtotal, 0));
+      const vatTotal = roundCents(calculatedLines.reduce((s, l) => s + l.vat_amount, 0));
+      const total = roundCents(subtotal + vatTotal);
+      const { data: offerId, error: rpcError } = await supabase2.rpc("create_offer_with_lines", {
+        p_company_id: companyId2,
+        p_customer_id: params.customerId || null,
+        p_type: params.type,
+        p_title: params.title,
+        p_offer_number: offerNumber,
+        p_content: params.content || null,
+        p_status: "draft",
+        p_valid_from: params.validFrom || null,
+        p_valid_until: params.validUntil || null,
+        p_notes: params.notes || null,
+        p_subtotal: subtotal,
+        p_vat_total: vatTotal,
+        p_total: total,
+        p_lines: calculatedLines
+      });
+      if (rpcError) {
+        return toErrorContent(sanitizeDbError("Failed to create offer", rpcError));
+      }
+      return toTextContent({
+        message: `${params.type === "sopimus" ? "Contract" : "Offer"} ${offerNumber} created`,
+        offer_id: offerId,
+        offer_number: offerNumber,
+        type: params.type,
+        title: params.title,
+        subtotal,
+        vat_total: vatTotal,
+        total,
+        lines: calculatedLines
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_update_offer_status",
+    "Update offer status with state machine validation. Valid transitions: draft\u2192sent, sent\u2192viewed/accepted/rejected/expired/draft, viewed\u2192accepted/rejected/expired/draft, accepted/rejected/expired\u2192draft.",
+    {
+      offerId: external_exports.string().uuid().describe("Offer UUID"),
+      status: external_exports.enum(["draft", "sent", "viewed", "accepted", "rejected", "expired"]).describe("New status")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: offer, error: fetchError } = await supabase2.from("offers").select("id, offer_number, status, invoice_id").eq("id", params.offerId).eq("company_id", companyId2).single();
+      if (fetchError || !offer) {
+        return toErrorContent(
+          `Offer ${params.offerId} not found. Use kirjapro_list_offers to find offer IDs.`
+        );
+      }
+      const currentStatus = offer.status;
+      const newStatus = params.status;
+      if (currentStatus === newStatus) {
+        return toErrorContent(
+          `Offer ${offer.offer_number} is already in status "${currentStatus}".`
+        );
+      }
+      const validNext = VALID_OFFER_TRANSITIONS[currentStatus] || [];
+      if (!validNext.includes(newStatus)) {
+        return toErrorContent(
+          `Cannot transition offer ${offer.offer_number} from "${currentStatus}" to "${newStatus}". Valid next statuses: ${validNext.length > 0 ? validNext.join(", ") : "(none)"}.`
+        );
+      }
+      if (newStatus === "draft" && offer.invoice_id) {
+        return toErrorContent(
+          `Cannot revert offer ${offer.offer_number} to draft \u2014 it has already been converted to an invoice.`
+        );
+      }
+      const updateFields = { status: newStatus };
+      const timestampMap = {
+        sent: "sent_at",
+        viewed: "viewed_at",
+        accepted: "accepted_at",
+        rejected: "rejected_at"
+      };
+      if (timestampMap[newStatus]) {
+        updateFields[timestampMap[newStatus]] = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      const { error: updateError } = await supabase2.from("offers").update(updateFields).eq("id", params.offerId).eq("company_id", companyId2);
+      if (updateError) {
+        return toErrorContent(sanitizeDbError("Failed to update offer status", updateError));
+      }
+      const { error: eventError } = await supabase2.from("offer_events").insert({
+        offer_id: params.offerId,
+        event_type: `status_${newStatus}`
+      });
+      if (eventError) {
+        console.error("Failed to log offer event:", eventError);
+      }
+      return toTextContent({
+        message: `Offer ${offer.offer_number} status changed from "${currentStatus}" to "${newStatus}"`,
+        offer_number: offer.offer_number,
+        previous_status: currentStatus,
+        new_status: newStatus
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_delete_offer",
+    'Delete a draft offer/contract. Only offers with status "draft" can be deleted.',
+    {
+      offerId: external_exports.string().uuid().describe("Offer UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: offer, error: fetchError } = await supabase2.from("offers").select("id, offer_number, status, type").eq("id", params.offerId).eq("company_id", companyId2).single();
+      if (fetchError || !offer) {
+        return toErrorContent(
+          `Offer ${params.offerId} not found. Use kirjapro_list_offers to find offer IDs.`
+        );
+      }
+      if (offer.status !== "draft") {
+        return toErrorContent(
+          `Cannot delete offer ${offer.offer_number} \u2014 status is "${offer.status}". Only draft offers can be deleted.`
+        );
+      }
+      const { error: deleteError } = await supabase2.from("offers").delete().eq("id", params.offerId).eq("company_id", companyId2);
+      if (deleteError) {
+        return toErrorContent(sanitizeDbError("Failed to delete offer", deleteError));
+      }
+      return toTextContent({
+        message: `Draft ${offer.type === "sopimus" ? "contract" : "offer"} ${offer.offer_number} deleted`,
+        offer_number: offer.offer_number
+      });
+    }
+  );
+}
+
+// src/tools/recurring-invoices.ts
+function registerRecurringInvoiceTools(server2) {
+  server2.tool(
+    "kirjapro_list_recurring_invoices",
+    "List recurring invoice templates with pagination. Shows frequency, next generation date, active status, and customer info.",
+    {
+      limit: external_exports.number().min(1).max(200).default(50).describe("Max results (default 50)"),
+      offset: external_exports.number().min(0).default(0).describe("Skip first N results"),
+      activeOnly: external_exports.boolean().default(true).describe("Only show active templates (default true)")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { limit, offset } = clampPagination(params.limit, params.offset);
+      let query = supabase2.from("recurring_invoices").select(
+        "id, name, frequency, next_date, end_date, is_active, auto_send, last_generated_at, times_generated, created_at, customer:customers(id, name)",
+        { count: "exact" }
+      ).eq("company_id", companyId2).order("next_date");
+      if (params.activeOnly) {
+        query = query.eq("is_active", true);
+      }
+      query = query.range(offset, offset + limit - 1);
+      const { data, count, error: error2 } = await query;
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to list recurring invoices", error2));
+      }
+      return toTextContent(paginate(data || [], count || 0, offset, limit));
+    }
+  );
+  server2.tool(
+    "kirjapro_get_recurring_invoice",
+    "Get a single recurring invoice template with full details including template data (lines, notes, payment terms) and generation history.",
+    {
+      recurringInvoiceId: external_exports.string().uuid().describe("Recurring invoice UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data, error: error2 } = await supabase2.from("recurring_invoices").select(
+        "*, customer:customers(id, name, business_id, email)"
+      ).eq("id", params.recurringInvoiceId).eq("company_id", companyId2).single();
+      if (error2 || !data) {
+        return toErrorContent(
+          `Recurring invoice ${params.recurringInvoiceId} not found. Use kirjapro_list_recurring_invoices to find IDs.`
+        );
+      }
+      const { data: logs } = await supabase2.from("recurring_invoice_logs").select("id, status, scheduled_date, invoice_number, error_message, created_at").eq("recurring_invoice_id", params.recurringInvoiceId).eq("company_id", companyId2).order("created_at", { ascending: false }).limit(10);
+      return toTextContent({
+        ...data,
+        recent_logs: logs || []
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_create_recurring_invoice",
+    "Create a new recurring invoice template. Specify customer, frequency, start date, and invoice line items. Invoices will be generated automatically on the schedule.",
+    {
+      customerId: external_exports.string().uuid().describe("Customer UUID"),
+      name: external_exports.string().min(1).max(200).describe('Template name (e.g. "Monthly hosting fee")'),
+      frequency: external_exports.enum(["weekly", "monthly", "quarterly", "yearly"]).describe("Generation frequency"),
+      nextDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe("First generation date (YYYY-MM-DD)"),
+      endDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Stop generating after this date"),
+      autoSend: external_exports.boolean().default(false).describe("Auto-send generated invoices (default false)"),
+      lines: external_exports.array(external_exports.object({
+        description: external_exports.string().describe("Line item description"),
+        quantity: external_exports.number().positive().describe("Quantity"),
+        unit: external_exports.string().default("kpl").describe('Unit (default "kpl")'),
+        unitPrice: external_exports.number().describe("Unit price (EUR)"),
+        vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).describe("VAT rate")
+      })).min(1).describe("Invoice line items"),
+      notes: external_exports.string().optional().describe("Invoice notes"),
+      paymentTermDays: external_exports.number().min(0).max(365).default(14).describe("Payment term in days")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: customer, error: custError } = await supabase2.from("customers").select("id, name").eq("id", params.customerId).eq("company_id", companyId2).maybeSingle();
+      if (custError || !customer) {
+        return toErrorContent(
+          `Customer ${params.customerId} not found. Use kirjapro_list_customers to find customer IDs.`
+        );
+      }
+      const templateData = {
+        lines: params.lines.map((l, i) => ({
+          line_number: i + 1,
+          description: l.description,
+          quantity: l.quantity,
+          unit: l.unit,
+          unit_price: l.unitPrice,
+          vat_rate: parseFloat(l.vatRate)
+        })),
+        notes: params.notes || null,
+        payment_terms_days: params.paymentTermDays
+      };
+      const { data, error: error2 } = await supabase2.from("recurring_invoices").insert({
+        company_id: companyId2,
+        customer_id: params.customerId,
+        name: params.name,
+        frequency: params.frequency,
+        next_date: params.nextDate,
+        end_date: params.endDate || null,
+        is_active: true,
+        auto_send: params.autoSend,
+        template_data: templateData
+      }).select().single();
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to create recurring invoice", error2));
+      }
+      return toTextContent({
+        message: `Recurring invoice "${params.name}" created for ${customer.name} (${params.frequency}, next: ${params.nextDate})`,
+        recurring_invoice: data
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_update_recurring_invoice",
+    "Update a recurring invoice template. Only provided fields are changed. Use this to pause/resume (isActive), change schedule, or update line items.",
+    {
+      recurringInvoiceId: external_exports.string().uuid().describe("Recurring invoice UUID"),
+      name: external_exports.string().min(1).max(200).optional().describe("Template name"),
+      frequency: external_exports.enum(["weekly", "monthly", "quarterly", "yearly"]).optional().describe("Generation frequency"),
+      nextDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Next generation date"),
+      endDate: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().nullable().describe("End date (null to remove)"),
+      isActive: external_exports.boolean().optional().describe("Active status (false to pause)"),
+      autoSend: external_exports.boolean().optional().describe("Auto-send generated invoices"),
+      lines: external_exports.array(external_exports.object({
+        description: external_exports.string().describe("Line item description"),
+        quantity: external_exports.number().positive().describe("Quantity"),
+        unit: external_exports.string().default("kpl").describe("Unit"),
+        unitPrice: external_exports.number().describe("Unit price (EUR)"),
+        vatRate: external_exports.enum(["25.5", "13.5", "10", "0"]).describe("VAT rate")
+      })).min(1).optional().describe("Replace all invoice lines"),
+      notes: external_exports.string().optional().nullable().describe("Invoice notes (null to remove)"),
+      paymentTermDays: external_exports.number().min(0).max(365).optional().describe("Payment term in days")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: existing, error: fetchError } = await supabase2.from("recurring_invoices").select("id, name, template_data").eq("id", params.recurringInvoiceId).eq("company_id", companyId2).single();
+      if (fetchError || !existing) {
+        return toErrorContent(
+          `Recurring invoice ${params.recurringInvoiceId} not found. Use kirjapro_list_recurring_invoices to find IDs.`
+        );
+      }
+      const updates = {};
+      if (params.name !== void 0) updates.name = params.name;
+      if (params.frequency !== void 0) updates.frequency = params.frequency;
+      if (params.nextDate !== void 0) updates.next_date = params.nextDate;
+      if (params.endDate !== void 0) updates.end_date = params.endDate;
+      if (params.isActive !== void 0) updates.is_active = params.isActive;
+      if (params.autoSend !== void 0) updates.auto_send = params.autoSend;
+      if (params.lines !== void 0 || params.notes !== void 0 || params.paymentTermDays !== void 0) {
+        const currentTemplate = existing.template_data || {};
+        const newTemplate = { ...currentTemplate };
+        if (params.lines !== void 0) {
+          newTemplate.lines = params.lines.map((l, i) => ({
+            line_number: i + 1,
+            description: l.description,
+            quantity: l.quantity,
+            unit: l.unit,
+            unit_price: l.unitPrice,
+            vat_rate: parseFloat(l.vatRate)
+          }));
+        }
+        if (params.notes !== void 0) newTemplate.notes = params.notes;
+        if (params.paymentTermDays !== void 0) newTemplate.payment_terms_days = params.paymentTermDays;
+        updates.template_data = newTemplate;
+      }
+      if (Object.keys(updates).length === 0) {
+        return toErrorContent("No fields to update. Provide at least one field to change.");
+      }
+      const { data, error: error2 } = await supabase2.from("recurring_invoices").update(updates).eq("id", params.recurringInvoiceId).eq("company_id", companyId2).select().single();
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to update recurring invoice", error2));
+      }
+      return toTextContent({
+        message: `Recurring invoice "${data.name}" updated`,
+        recurring_invoice: data,
+        fields_changed: Object.keys(updates)
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_delete_recurring_invoice",
+    "Delete a recurring invoice template. Previously generated invoices are NOT affected.",
+    {
+      recurringInvoiceId: external_exports.string().uuid().describe("Recurring invoice UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: existing, error: fetchError } = await supabase2.from("recurring_invoices").select("id, name").eq("id", params.recurringInvoiceId).eq("company_id", companyId2).single();
+      if (fetchError || !existing) {
+        return toErrorContent(
+          `Recurring invoice ${params.recurringInvoiceId} not found. Use kirjapro_list_recurring_invoices to find IDs.`
+        );
+      }
+      const { error: error2 } = await supabase2.from("recurring_invoices").delete().eq("id", params.recurringInvoiceId).eq("company_id", companyId2);
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to delete recurring invoice", error2));
+      }
+      return toTextContent({
+        message: `Recurring invoice "${existing.name}" deleted. Previously generated invoices are unaffected.`
+      });
+    }
+  );
+  server2.tool(
+    "kirjapro_trigger_recurring_invoice",
+    "Manually trigger generation of a recurring invoice now, regardless of its next scheduled date. Returns the generated invoice.",
+    {
+      recurringInvoiceId: external_exports.string().uuid().describe("Recurring invoice UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data: existing, error: fetchError } = await supabase2.from("recurring_invoices").select("id, name, is_active").eq("id", params.recurringInvoiceId).eq("company_id", companyId2).single();
+      if (fetchError || !existing) {
+        return toErrorContent(
+          `Recurring invoice ${params.recurringInvoiceId} not found. Use kirjapro_list_recurring_invoices to find IDs.`
+        );
+      }
+      if (!existing.is_active) {
+        return toErrorContent(
+          `Recurring invoice "${existing.name}" is paused. Activate it first with kirjapro_update_recurring_invoice.`
+        );
+      }
+      const result = await invokeEdgeFunction(
+        supabase2,
+        "generate-recurring-invoices",
+        { recurring_invoice_id: params.recurringInvoiceId, company_id: companyId2 }
+      );
+      if (result.error !== null) {
+        return toErrorContent(result.error);
+      }
+      return toTextContent({
+        message: `Invoice generated from "${existing.name}"`,
+        ...result.data
+      });
+    }
+  );
+}
+
+// src/tools/received-invoices.ts
+function registerReceivedInvoiceTools(server2) {
+  server2.tool(
+    "kirjapro_list_received_invoices",
+    "List received (purchase) invoices with pagination and filters. Shows sender, amounts, status, and due dates.",
+    {
+      limit: external_exports.number().min(1).max(200).default(50).describe("Max results (default 50)"),
+      offset: external_exports.number().min(0).default(0).describe("Skip first N results"),
+      status: external_exports.enum(["new", "reviewed", "approved", "rejected", "booked"]).optional().describe("Filter by status"),
+      search: external_exports.string().optional().describe("Search by sender name, invoice number, or business ID"),
+      dateFrom: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Invoice date from (YYYY-MM-DD)"),
+      dateTo: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Invoice date to (YYYY-MM-DD)")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { limit, offset } = clampPagination(params.limit, params.offset);
+      let query = supabase2.from("received_invoices").select(
+        "id, sender_business_id, sender_name, invoice_number, invoice_date, due_date, total_amount, vat_amount, currency, payment_reference, iban, status, created_at",
+        { count: "exact" }
+      ).eq("company_id", companyId2).order("created_at", { ascending: false });
+      if (params.status) {
+        query = query.eq("status", params.status);
+      }
+      if (params.search) {
+        const s = escapeLike(params.search);
+        query = query.or(
+          `sender_name.ilike.%${s}%,invoice_number.ilike.%${s}%,sender_business_id.ilike.%${s}%`
+        );
+      }
+      if (params.dateFrom) {
+        query = query.gte("invoice_date", params.dateFrom);
+      }
+      if (params.dateTo) {
+        query = query.lte("invoice_date", params.dateTo);
+      }
+      query = query.range(offset, offset + limit - 1);
+      const { data, count, error: error2 } = await query;
+      if (error2) {
+        return toErrorContent(sanitizeDbError("Failed to list received invoices", error2));
+      }
+      const results = (data || []).map((inv) => ({
+        ...inv,
+        total_amount_formatted: inv.total_amount != null ? formatCurrency(inv.total_amount) : null
+      }));
+      return toTextContent(paginate(results, count || 0, offset, limit));
+    }
+  );
+  server2.tool(
+    "kirjapro_get_received_invoice",
+    "Get a single received invoice with full details including sender info, line items, and linked transaction.",
+    {
+      receivedInvoiceId: external_exports.string().uuid().describe("Received invoice UUID")
+    },
+    async (params) => {
+      const supabase2 = getSupabase();
+      const companyId2 = getCompanyId();
+      const { data, error: error2 } = await supabase2.from("received_invoices").select("*").eq("id", params.receivedInvoiceId).eq("company_id", companyId2).single();
+      if (error2 || !data) {
+        return toErrorContent(
+          `Received invoice ${params.receivedInvoiceId} not found. Use kirjapro_list_received_invoices to find IDs.`
+        );
+      }
+      let linkedTransaction = null;
+      if (data.transaction_id) {
+        const { data: tx } = await supabase2.from("transactions").select("id, transaction_date, description, document_number").eq("id", data.transaction_id).eq("company_id", companyId2).single();
+        linkedTransaction = tx;
+      }
+      return toTextContent({
+        ...data,
+        total_amount_formatted: data.total_amount != null ? formatCurrency(data.total_amount) : null,
+        vat_amount_formatted: data.vat_amount != null ? formatCurrency(data.vat_amount) : null,
+        linked_transaction: linkedTransaction
+      });
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerTools(server2) {
+  registerAccountTools(server2);
+  registerTransactionTools(server2);
+  registerTemplateTools(server2);
+  registerBookingTools(server2);
+  registerInvoiceTools(server2);
+  registerCustomerTools(server2);
+  registerReportTools(server2);
+  registerBankingTools(server2);
+  registerValidationTools(server2);
+  registerFiscalYearTools(server2);
+  registerOfferTools(server2);
+  registerRecurringInvoiceTools(server2);
+  registerReceivedInvoiceTools(server2);
+}
+
+// src/resources/schema.ts
+var CHART_OF_ACCOUNTS_SUMMARY = {
+  standard: "YSE 2017",
+  ranges: [
+    { range: "1000-1299", type: "asset", label: "Pysyv\xE4t vastaavat (fixed assets)", examples: "1130 Koneet ja kalusto, 1210 Osakkeet" },
+    { range: "2000-2399", type: "asset", label: "Vaihtuvat vastaavat (current assets)", examples: "2110 Myyntisaamiset, 2140 ALV-saamiset, 2310 Kassa, 2320 Pankkitili" },
+    { range: "3000-3099", type: "equity", label: "Oma p\xE4\xE4oma (equity)", examples: "3010 Osakep\xE4\xE4oma, 3030 SVOP, 3050 Tilikauden tulos" },
+    { range: "4000-4099", type: "liability", label: "Vieras p\xE4\xE4oma (liabilities)", examples: "4030 Ostovelat, 4050 ALV-velka, 4060 Ennakonpid\xE4tysvelka, 4080 TyEL-velka" },
+    { range: "5000-5199", type: "revenue", label: "Tuotot (revenue)", examples: "5010 Myynti 25,5%, 5020 Myynti 13,5%, 5040 Myynti 0%" },
+    { range: "6000-6099", type: "expense", label: "Materiaalit ja palvelut", examples: "6010 Ostot, 6030 Ulkopuoliset palvelut" },
+    { range: "7000-7599", type: "expense", label: "Henkil\xF6st\xF6 ja poistot", examples: "7010 Palkat, 7020 El\xE4kekulut, 7510 Poistot" },
+    { range: "8000-8499", type: "expense", label: "Liiketoiminnan muut kulut", examples: "8010 Toimitila, 8050 Markkinointi, 8060 Hallinto, 8070 Vakuutukset" },
+    { range: "9000-9099", type: "expense", label: "Tuloverot", examples: "9010 Tilikauden tuloverot" }
+  ],
+  note: "Use kirjapro_list_accounts to get full account list with search/filter."
+};
+var VAT_RATES = [
+  { rate: 25.5, label: "Yleinen verokanta", description: "Standard rate for most goods and services (from 1.9.2024, was 24%)", basis: "AVL 84\xA7" },
+  { rate: 13.5, label: "Alennettu verokanta", description: "Food, animal feed, restaurants, transport, accommodation, books, medicine, sports, culture, performing artists, sanitary products, broadcasting (from 1.1.2026, was 14%)", basis: "AVL 85\xA7, 85a\xA7" },
+  { rate: 10, label: "Lehdet ja aikakauslehdet", description: "Newspapers and magazines (print and digital) only", basis: "AVL 85a\xA7" },
+  { rate: 0, label: "Nollaverokanta", description: "Exports (AVL 70\xA7), intra-EU B2B supplies (AVL 72a\xA7), vessels, international transport. Input VAT deductible", basis: "AVL 55-72h\xA7" },
+  { rate: null, label: "Verovapaat myynnit", description: "Healthcare (AVL 34-36\xA7), education (AVL 39-40\xA7), financial services (AVL 41-42\xA7), insurance (AVL 44\xA7). NO input VAT deduction", basis: "AVL 34-44\xA7" }
+];
+function registerSchemaResources(server2) {
+  server2.resource(
+    "chart-of-accounts",
+    "kirjapro://accounts/chart",
+    {
+      description: "Finnish chart of accounts summary (YSE 2017). Shows account number ranges and common accounts per category. Use kirjapro_list_accounts tool for full detail.",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(CHART_OF_ACCOUNTS_SUMMARY)
+      }]
+    })
+  );
   server2.resource(
     "vat-rates",
     "kirjapro://vat-rates",
     {
-      description: "Finnish VAT rates (2026). Rates: 25.5% (general), 13.5% (food/restaurants), 10% (books/medicine), 0% (exempt).",
+      description: "Finnish VAT rates (2026). Rates: 25.5% (general), 13.5% (food/restaurants/books/medicine/transport/accommodation/sports), 10% (newspapers/magazines only), 0% (exports/vessels \u2014 input VAT deductible), exempt (healthcare/education/finance/insurance \u2014 NO input VAT deduction).",
       mimeType: "application/json"
     },
     async (uri) => ({
       contents: [{
         uri: uri.href,
         mimeType: "application/json",
-        text: JSON.stringify(VAT_RATES, null, 2)
+        text: JSON.stringify(VAT_RATES)
       }]
     })
   );
@@ -22687,7 +24301,7 @@ function registerCompanyResources(server2) {
         contents: [{
           uri: uri.href,
           mimeType: "application/json",
-          text: JSON.stringify(company || {}, null, 2)
+          text: JSON.stringify(company || {})
         }]
       };
     }
@@ -22703,27 +24317,341 @@ function registerCompanyResources(server2) {
       const supabase2 = getSupabase();
       const companyId2 = getCompanyId();
       const { data: fiscalYears } = await supabase2.from("fiscal_years").select("id, start_date, end_date, is_closed, created_at").eq("company_id", companyId2).order("start_date", { ascending: false });
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const enriched = (fiscalYears || []).map((fy) => ({
+        ...fy,
+        is_current: !fy.is_closed && fy.start_date <= today && fy.end_date >= today
+      }));
       return {
         contents: [{
           uri: uri.href,
           mimeType: "application/json",
-          text: JSON.stringify(fiscalYears || [], null, 2)
+          text: JSON.stringify(enriched)
         }]
       };
     }
   );
 }
 
+// src/resources/compliance.ts
+var VAT_COMPLIANCE = {
+  rates: {
+    current_year: 2026,
+    standard: { rate: 25.5, finnish: "Yleinen verokanta", effective: "2024-09-01", basis: "AVL 84\xA7", examples: "IT services, consulting, retail, construction, telecom, energy" },
+    reduced: { rate: 13.5, finnish: "Alennettu verokanta", effective: "2026-01-01", basis: "AVL 85\xA7, 85a\xA7", examples: "Food, animal feed, restaurants, transport, accommodation, books, medicine, sports, culture, performing artists, sanitary products, broadcasting" },
+    second_reduced: { rate: 10, finnish: "Toinen alennettu verokanta", basis: "AVL 85a\xA7", examples: "Newspapers, magazines, digital periodicals only" },
+    zero: { rate: 0, finnish: "Nollaverokanta", basis: "AVL 55-72h\xA7", examples: "Exports outside EU, intra-community supplies, vessels (sale/rental/chartering), international transport" },
+    exempt: { rate: null, finnish: "Verovapaat myynnit", basis: "AVL 34-44\xA7", examples: "Healthcare (AVL 34-36\xA7), education (AVL 39-40\xA7), financial services (AVL 41-42\xA7), insurance (AVL 44\xA7), social services (AVL 37-38\xA7), real estate transfers (AVL 27-28\xA7)" }
+  },
+  rate_history: [
+    { period: "1.1.2026 \u2192", standard: 25.5, reduced: 13.5, second_reduced: 10, note: "Reduced rate unified from 14% \u2192 13.5%" },
+    { period: "1.9.2024 \u2192 31.12.2025", standard: 25.5, reduced: 14, second_reduced: 10, note: "Standard raised from 24% \u2192 25.5%" },
+    { period: "1.1.2013 \u2192 31.8.2024", standard: 24, reduced: 14, second_reduced: 10 }
+  ],
+  deduction_rules: [
+    { type: "Edustuskulut (entertainment)", vat_deduction: "0%", income_tax: "50%", basis: "AVL 114\xA7", booking: "Full gross to expense, NO ALV-saamiset entry" },
+    { type: "Neuvottelukulut (meetings)", vat_deduction: "100%", income_tax: "100%", basis: "AVL 102\xA7", booking: "Normal VAT split" },
+    { type: "Henkil\xF6st\xF6kulut (staff events)", vat_deduction: "100%", income_tax: "100%", basis: "AVL 102\xA7", booking: "Normal VAT split" },
+    { type: "Insurance premiums", vat_deduction: "0% (exempt)", income_tax: "100%", basis: "AVL 44\xA7", booking: "Full gross to expense, no VAT (vakuutusmaksuvero is separate)" },
+    { type: "Healthcare (staff)", vat_deduction: "0% (exempt)", income_tax: "100%", basis: "AVL 34-36\xA7" },
+    { type: "Financial services", vat_deduction: "0% (exempt)", income_tax: "100%", basis: "AVL 41-42\xA7" },
+    { type: "Henkil\xF6auto (passenger car M1)", vat_deduction: "100% if exclusive business use, 0% if ANY private use (incl. commuting)", income_tax: "Proportional", basis: "AVL 114\xA7 1 mom 4 kohta", booking: "Ajop\xE4iv\xE4kirja (mileage logbook) required as proof" },
+    { type: "Pakettiauto/kuorma-auto (van N1+)", vat_deduction: "Proportional to business use", income_tax: "Proportional", basis: "AVL 102\xA7, 117\xA7" },
+    { type: "Markkinointitilaisuudet (marketing events)", vat_deduction: "100%", income_tax: "100%", basis: "AVL 102\xA7, KHO 2013:63", booking: "Product launches, trade shows \u2014 NOT client entertainment" }
+  ],
+  reverse_charge: {
+    rule: "Buyer self-assesses both output and input VAT. Applies to: (1) foreign B2B providers not charging Finnish VAT, (2) domestic construction services, (3) metal scrap, (4) emissions allowances, (5) investment gold",
+    basis: "AVL 8a-8d\xA7, 9\xA7, 65\xA7; EU VAT Directive Art. 196, Art. 199",
+    scenarios: [
+      { type: "Foreign B2B", basis: "AVL 9\xA7", note: "Most common: EU and non-EU service providers" },
+      { type: "Construction services", basis: "AVL 8c\xA7", note: 'Since 1.4.2011. Buyer must itself sell/rent construction services "not just occasionally". Regular company commissioning renovation: NO reverse charge' },
+      { type: "Metal scrap and waste", basis: "AVL 8d\xA7", note: "Since 1.1.2015. Between VAT-registered entities" },
+      { type: "Emissions allowances", basis: "AVL 8b\xA7", note: "Greenhouse gas emission allowances" },
+      { type: "Investment gold", basis: "AVL 8a\xA7", note: "Taxable investment gold, gold materials, gold semi-finished products" }
+    ],
+    booking: "4 entries: D expense + D ALV-saamiset + C bank + C ALV-velka (k\xE4\xE4nnetty)",
+    note: "Net VAT effect is zero but BOTH must be reported on ALV-ilmoitus. Invoice must NOT show VAT rate or VAT amount",
+    omavero_fields: "Foreign: 305 (EU goods), 306 (EU services). Domestic construction/scrap: 318 (VAT amount), 319/320 (tax bases)"
+  },
+  common_mistakes: [
+    "Food/coffee at 25.5% \u2014 should be 13.5% (AVL 85\xA7)",
+    "Train ticket at 10% \u2014 should be 13.5% (transport = reduced rate)",
+    "Using 14% after 1.1.2026 \u2014 rate changed to 13.5%",
+    "Restaurant alcohol at 13.5% \u2014 alcohol is 25.5% even at restaurants",
+    "Newspaper/magazine at 13.5% \u2014 periodicals are 10%",
+    "Splitting VAT from insurance premium \u2014 insurance is VAT-exempt, not zero-rated",
+    "Deducting vakuutusmaksuvero as input VAT \u2014 it is not ALV"
+  ]
+};
+var INVOICE_REQUIREMENTS = {
+  legal_basis: "AVL 209 e \xA7, EU VAT Directive Art. 226",
+  source: "https://www.vero.fi/syventavat-vero-ohjeet/ohje-hakusivu/48090/laskutusvaatimukset-arvonlisaverotuksessa3/",
+  total_markings: 18,
+  mandatory_fields: [
+    { kohta: 1, field: "Laskun antamisp\xE4iv\xE4", english: "Invoice date", status: "implemented", relevance: "always" },
+    { kohta: 2, field: "Juokseva tunniste", english: "Sequential invoice number", status: "implemented", relevance: "always", note: "Gaps must be detectable per Vero requirement" },
+    { kohta: 3, field: "Myyj\xE4n ALV-tunniste", english: "Seller VAT ID (FI + Y-tunnus)", status: "implemented", relevance: "always", note: "Y-tunnus always required; FI-format strictly mandatory for EU cross-border" },
+    { kohta: 4, field: "Ostajan ALV-tunniste", english: "Buyer VAT ID", status: "implemented", relevance: "conditional", note: "Required for reverse charge and EU B2B" },
+    { kohta: 5, field: "Myyj\xE4n ja ostajan nimi ja osoite", english: "Names and addresses", status: "implemented", relevance: "always" },
+    { kohta: 6, field: "Tavaroiden/palvelujen kuvaus ja m\xE4\xE4r\xE4", english: "Description and quantity", status: "implemented", relevance: "always" },
+    { kohta: 7, field: "Toimitusp\xE4iv\xE4 / suoritusp\xE4iv\xE4", english: "Delivery date", status: "partial", relevance: "conditional", note: "NOT required when same as invoice date (Vero.fi 5.1.7). Required when different" },
+    { kohta: 8, field: "Veron peruste, yksikk\xF6hinta, alennukset", english: "Tax base, unit price, discounts", status: "implemented", relevance: "always" },
+    { kohta: 9, field: "Verokanta", english: "VAT rate", status: "implemented", relevance: "always" },
+    { kohta: 10, field: "Suoritettavan veron m\xE4\xE4r\xE4", english: "VAT amount", status: "implemented", relevance: "always" },
+    { kohta: 11, field: "Merkint\xE4 verottomuudesta", english: "Tax exemption notation", status: "gap", relevance: "conditional", note: 'Simple "Veroton myynti" suffices. Citing AVL section is recommended but not mandatory (Vero.fi 5.1.11)' },
+    { kohta: 12, field: "Merkint\xE4 k\xE4\xE4nnetyst\xE4 verovelvollisuudesta", english: "Reverse charge notation", status: "gap", relevance: "conditional", note: '"K\xE4\xE4nnetty verovelvollisuus" phrase is mandatory. Legal basis citation is recommended, not required' },
+    { kohta: 13, field: "Merkint\xE4 itselaskutuksesta", english: "Self-billing notation", status: "n/a", relevance: "situational", note: "When buyer issues invoice on seller behalf" },
+    { kohta: 14, field: "Uuden kuljetusv\xE4lineen tiedot", english: "New means of transport details", status: "n/a", relevance: "situational" },
+    { kohta: 15, field: "Voittomarginaalij\xE4rjestelm\xE4", english: "Margin scheme (used goods)", status: "n/a", relevance: "situational" },
+    { kohta: 16, field: "Voittomarginaalij\xE4rjestelm\xE4 \u2014 matkatoimistot", english: "Margin scheme (travel agents)", status: "n/a", relevance: "situational" },
+    { kohta: 17, field: "Verollisen sijoituskullan myynti", english: "Taxable investment gold", status: "n/a", relevance: "situational" },
+    { kohta: 18, field: "Viittaus alkuper\xE4iseen laskuun", english: "Credit note reference (muutoslasku)", status: "not_implemented", relevance: "conditional", note: "Only mandatory requirement: unambiguous reference to original invoice" }
+  ],
+  simplified_invoice: {
+    threshold: 400,
+    note: "Invoices \u2264 400 \u20AC may use simplified format (AVL 209 f \xA7). Also: retail to consumers, restaurant/catering, passenger transport \u2014 regardless of amount"
+  },
+  muutoslasku: {
+    status: "not_implemented",
+    mandatory: "Unambiguous reference to original invoice (number or period)",
+    recommended: "Hyvityslasku label, reason for credit, same numbering sequence \u2014 common practice, not legally mandated"
+  }
+};
+var FILING_DEADLINES = {
+  vat_filing: {
+    thresholds: [
+      { revenue: "< 30,000 \u20AC", periods: ["monthly", "quarterly", "annually"], note: "Annual: deadline last day of February of following year (28.2 or 29.2 in leap year)" },
+      { revenue: "30,000\u2013100,000 \u20AC", periods: ["monthly", "quarterly"], note: "Quarterly: 12th of 2nd month after quarter" },
+      { revenue: "> 100,000 \u20AC", periods: ["monthly"], note: "Monthly: 12th of 2nd month after reporting month" }
+    ],
+    monthly_example: "January 2026 VAT \u2192 deadline 12.3.2026",
+    quarterly_deadlines: {
+      Q1: "12.5",
+      Q2: "12.8",
+      Q3: "12.11",
+      Q4: "12.2 (next year)"
+    }
+  },
+  tyel: {
+    monthly_report: "5th of following month \u2192 pension company",
+    payment: "20th of following month \u2192 pension company"
+  },
+  tulorekisteri: {
+    palkkatietoilmoitus: "5 calendar days from payment date \u2192 Tulorekisteri",
+    tyonantajan_erillisilmoitus: "5th of following month \u2192 Tulorekisteri (sotu totals)"
+  },
+  sairausvakuutusmaksu_payment: "12th of following month \u2192 Vero (OmaVero, oma-aloitteinen)",
+  tilinpaatos: "4 months from fiscal year end (KPL 3:6)",
+  prh_filing: "8 months from fiscal year end (OYL 8:10)",
+  pienyrittaja: {
+    threshold: 2e4,
+    note: "Revenue under 20,000 \u20AC/year: no VAT registration obligation (from 1.1.2025, was 15,000 \u20AC)",
+    alarajahuojennus: "REMOVED from 1.1.2025 \u2014 hard threshold, no progressive relief"
+  },
+  maksuperusteinen_alv: {
+    threshold: 5e5,
+    note: "Revenue under 500,000 \u20AC: may opt for cash-basis VAT (report when payment received/made, not when invoiced)",
+    application: "Opt-in via OmaVero"
+  },
+  late_penalties: {
+    myohastymismaksu: "3 \u20AC/day for days 1-45 (max 135 \u20AC), then +2% of tax amount (max 15,000 \u20AC per tax type)",
+    viivastyskorko_2026: "9.5% for most taxes, 4.5% for inheritance tax",
+    correction_grace: "Corrections within 45 days of original deadline: no penalty if change \u2264 500 \u20AC",
+    nil_return: "Even when no VAT activity occurred, a nil return must be filed for each verokausi"
+  },
+  payment_deadline: "Same as filing deadline (12th of M+2 for monthly/quarterly, last day of Feb for annual)",
+  omavero_field_codes: {
+    source: "VSRALVKV tietuekuvaus v1.10 (27.2.2026)",
+    source_url: "https://www.vero.fi/contentassets/ef5905e0f5b74bcba89aa9ba9c34015d/verohallinto_tietuekuvaus_vsralvkv_290824.pdf",
+    vat_amounts: {
+      301: "Suoritettava 24%/25,5% vero kotimaan myynnist\xE4 (domestic sales standard rate)",
+      302: "Suoritettava 14%/13,5% vero kotimaan myynnist\xE4 (domestic sales reduced rate)",
+      303: "Suoritettava 10% vero kotimaan myynnist\xE4 (domestic sales 10%)",
+      304: "Vero tavaroiden maahantuonnista EU:n ulkopuolelta (import VAT from outside EU)",
+      305: "Vero tavaraostoista muista EU-maista (reverse charge VAT on EU goods)",
+      306: "Vero palveluostoista muista EU-maista (reverse charge VAT on EU services)",
+      307: "Verokauden v\xE4hennett\xE4v\xE4 vero (total deductible input VAT)",
+      308: "Maksettava vero / Palautukseen oikeuttava vero (net payable/refundable). Formula: (301+302+303+304+305+306+318) - 307",
+      318: "Vero rakentamispalvelun ja metalliromun ostoista (construction/scrap reverse charge VAT)"
+    },
+    tax_bases: {
+      309: "0-verokannan alainen liikevaihto (zero-rate turnover: exports, EU sales with deduction right)",
+      310: "Tavaroiden maahantuonnit EU:n ulkopuolelta (goods imports from outside EU)",
+      311: "Tavaroiden myynnit muihin EU-maihin (goods sales to EU)",
+      312: "Palveluiden myynnit muihin EU-maihin (service sales to EU)",
+      313: "Tavaraostot muista EU-maista (goods purchases from EU)",
+      314: "Palveluostot muista EU-maista (service purchases from EU)",
+      319: "Rakentamispalvelun ja metalliromun myynnit (construction/scrap sales)",
+      320: "Rakentamispalvelun ja metalliromun ostot (construction/scrap purchases)"
+    },
+    removed_2025: "315, 316, 317 (alarajahuojennus fields) removed from 1.1.2025"
+  }
+};
+var SOCIAL_INSURANCE_2026 = {
+  year: 2026,
+  sources: [
+    "https://www.etk.fi/ajankohtaista/tyoelakemaksut-vuonna-2026/",
+    "https://www.elo.fi/fi-fi/tyonantaja/tyel-vakuuttaminen/tyel-maksu/sosiaalivakuutusmaksut-2026",
+    "https://tyel-vakuutus.fi/tyonantajan-sivukulut/"
+  ],
+  tyel: {
+    keskimaarainen: 24.4,
+    perusmaksu: 24.85,
+    tilapaistyonantaja: 25.85,
+    employee: 7.3,
+    employer_average: 17.1,
+    employer_perusmaksu: 17.55,
+    note: "Perusmaksu 24.85% is what pension companies bill before company-specific adjustments. Keskim\xE4\xE4r\xE4inen 24.40% is the actual average. Age differentiation eliminated in 2026 (ETK)"
+  },
+  sotu: {
+    rate: 1.91,
+    payer: "employer",
+    note: "Sairausvakuutusmaksu, up from 1.87% in 2025. Paid monthly to Vero"
+  },
+  ttv: {
+    employer: 0.31,
+    employee: 0.89,
+    note: "Ty\xF6tt\xF6myysvakuutus. Employer rate 0.31% for payroll \u2264 2,509,500 \u20AC; 1.23% above. Employee up from 0.59% in 2025"
+  },
+  tapaturma: {
+    average: 0.51,
+    range: "0.05\u20135.00%",
+    payer: "employer",
+    note: "Company-specific rate based on industry and claims history"
+  },
+  ryhmahenkivakuutus: {
+    rate: 0.06,
+    payer: "employer",
+    note: "Standardized via collective agreement"
+  },
+  total_employer_side_costs: "~20% of gross salary (incl. TyEL employer share)",
+  accounts: {
+    salary: "7010 Palkat ja palkkiot",
+    tyel_expense: "7020 El\xE4kekulut (TyEL)",
+    sotu_expense: "7030 Muut henkil\xF6sivukulut",
+    withholding_payable: "4060 Ennakonpid\xE4tysvelka",
+    tyel_payable: "4080 TyEL-velka",
+    ttv_payable: "4070 Sosiaaliturvamaksuvelka",
+    bank: "2320 Pankkitili"
+  }
+};
+var BOOKKEEPING_RULES = {
+  legal_basis: "Kirjanpitolaki 1336/1997",
+  core_principles: [
+    { rule: "Double-entry (kahdenkertainen kirjanpito)", basis: "KPL 2:1", note: "Every entry: total debits = total credits" },
+    { rule: "Voucher principle (tositeperiaate)", basis: "KPL 2:5", note: "Every entry must be based on a numbered voucher" },
+    { rule: "Audit trail (kirjausketju)", basis: "KPL 2:6", note: "Tosite \u2192 tositenumero \u2192 p\xE4iv\xE4kirja \u2192 p\xE4\xE4kirja \u2192 tilinp\xE4\xE4t\xF6s \u2014 unbroken chain" },
+    { rule: "Sequential numbering", basis: "KPL 2:5", note: "Gap detection must be possible from the numbering sequence" },
+    { rule: "Closed period immutability", basis: "KPL 2:7", note: "Corrections to closed periods must use new entries in current period" }
+  ],
+  retention: [
+    { type: "Accounting records (kirjanpitokirjat)", years: 10, basis: "KPL 2:10 1 mom" },
+    { type: "Financial statements (tilinp\xE4\xE4t\xF6s)", years: 10, basis: "KPL 3:9" },
+    { type: "Vouchers, invoices (tositteet)", years: 6, basis: "KPL 2:10 2 mom" },
+    { type: "E-invoice XML originals", years: 6, basis: "KPL 2:7" }
+  ],
+  fiscal_year: {
+    normal_duration: "12 months",
+    max_duration: "18 months (first/changed period only)",
+    tilinpaatos_deadline: "4 months from fiscal year end",
+    prh_deadline: "8 months from fiscal year end (Oy, Oyj)"
+  },
+  company_sizes: [
+    { class: "Mikroyritys", revenue: "< 900K", balance: "< 450K", employees: "< 10", tilinpaatos: "Simplified (PMA)" },
+    { class: "Pienyritys", revenue: "< 15M", balance: "< 7.5M", employees: "< 50", tilinpaatos: "Standard (PMA)" },
+    { class: "Keskisuuri", revenue: "< 50M", balance: "< 25M", employees: "< 250", tilinpaatos: "Full (KPA) + toimintakertomus for Oy/Osk" },
+    { class: "Suuryritys", revenue: "\u2265 50M", balance: "\u2265 25M", employees: "\u2265 250", tilinpaatos: "Full + toimintakertomus + rahoituslaskelma" }
+  ]
+};
+function registerComplianceResources(server2) {
+  server2.resource(
+    "compliance-vat",
+    "kirjapro://compliance/vat",
+    {
+      description: "Finnish VAT compliance: rates (25.5/13.5/10/0%/exempt), rate history, deduction rules (edustus/neuvottelu/insurance), reverse charge, and common mistakes. CRITICAL: 0% (zero-rated, input VAT deductible) \u2260 exempt (no input VAT deduction). Legal basis: AVL 1501/1993.",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(VAT_COMPLIANCE)
+      }]
+    })
+  );
+  server2.resource(
+    "compliance-invoicing",
+    "kirjapro://compliance/invoicing",
+    {
+      description: "Invoice requirements per AVL 209 e \xA7: 18 mandatory markings (kohdat 1-18), muutoslasku/hyvityslasku rules, simplified invoice (\u2264400\u20AC + retail/restaurant). Shows implementation status. Source: vero.fi",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(INVOICE_REQUIREMENTS)
+      }]
+    })
+  );
+  server2.resource(
+    "compliance-deadlines",
+    "kirjapro://compliance/deadlines",
+    {
+      description: "Finnish tax filing deadlines: VAT verokausi thresholds (<30K annual, <100K quarterly, >100K monthly), TyEL reporting, tilinp\xE4\xE4t\xF6s deadlines, pienyritt\xE4j\xE4 20K\u20AC threshold, maksuperusteinen ALV.",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(FILING_DEADLINES)
+      }]
+    })
+  );
+  server2.resource(
+    "compliance-social-insurance",
+    "kirjapro://compliance/social-insurance",
+    {
+      description: "2026 Finnish social insurance rates: TyEL (perusmaksu 24.85%, keskim\xE4\xE4r\xE4inen 24.40%, employee 7.30%), sotu (1.91%), TTV (0.31%/0.89%), tapaturma (~0.51%), ryhm\xE4henki (0.06%). Sources: ETK, Elo, tyel-vakuutus.fi",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(SOCIAL_INSURANCE_2026)
+      }]
+    })
+  );
+  server2.resource(
+    "compliance-bookkeeping",
+    "kirjapro://compliance/bookkeeping",
+    {
+      description: "KPL (Kirjanpitolaki) requirements: double-entry, audit trail, voucher principle, retention periods (10/6 years), fiscal year rules (max 18 months), company size classification (mikro/pien/keski/suuri).",
+      mimeType: "application/json"
+    },
+    async (uri) => ({
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: JSON.stringify(BOOKKEEPING_RULES)
+      }]
+    })
+  );
+}
+
 // src/resources/index.ts
 function registerResources(server2) {
   registerSchemaResources(server2);
   registerCompanyResources(server2);
+  registerComplianceResources(server2);
 }
 
 // src/index.ts
 var server = new McpServer({
   name: "kirjapro",
-  version: "0.2.0"
+  version: "0.5.0"
 });
 async function main() {
   try {