@opentabs-dev/opentabs-plugin-ynab 0.0.85 → 0.0.87

package/dist/adapter.iife.js

@@ -329,162 +329,6 @@
     configSchema;
   };
 
-  // src/ynab-api.ts
-  var generateDeviceId = () => crypto.randomUUID();
-  var extractPlanId = () => {
-    const url2 = getCurrentUrl();
-    const match = url2.match(/app\.ynab\.com\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/);
-    return match?.[1] ?? null;
-  };
-  var getAuth = () => {
-    const cached2 = getAuthCache("ynab");
-    if (cached2?.sessionToken && cached2.planId) return cached2;
-    const sessionToken = getMetaContent("session-token");
-    if (!sessionToken) return null;
-    const user = getPageGlobal("YNAB_CLIENT_CONSTANTS.USER");
-    if (!user?.id) return null;
-    const planId = extractPlanId();
-    if (!planId) return null;
-    const deviceId = cached2?.deviceId ?? generateDeviceId();
-    const auth = {
-      sessionToken,
-      deviceId,
-      userId: user.id,
-      planId
-    };
-    setAuthCache("ynab", auth);
-    return auth;
-  };
-  var isAuthenticated = () => getAuth() !== null;
-  var waitForAuth = () => waitUntil(() => isAuthenticated(), { interval: 500, timeout: 5e3 }).then(
-    () => true,
-    () => false
-  );
-  var getPlanId = () => {
-    const auth = getAuth();
-    if (!auth) throw ToolError.auth("Not authenticated \u2014 please log in to YNAB.");
-    return auth.planId;
-  };
-  var getHeaders = () => {
-    const auth = getAuth();
-    if (!auth) throw ToolError.auth("Not authenticated \u2014 please log in to YNAB.");
-    const appVersion = getPageGlobal("YNAB_CLIENT_CONSTANTS.YNAB_APP_VERSION");
-    const headers = {
-      "X-Session-Token": auth.sessionToken,
-      "X-YNAB-Device-Id": auth.deviceId,
-      "X-YNAB-Device-OS": "web",
-      "X-Requested-With": "XMLHttpRequest",
-      Accept: "application/json, text/javascript, */*; q=0.01"
-    };
-    if (appVersion) headers["X-YNAB-Device-App-Version"] = appVersion;
-    return headers;
-  };
-  var handleApiError = async (response, context) => {
-    const errorBody = (await response.text().catch(() => "")).substring(0, 512);
-    if (response.status === 426) {
-      clearAuthCache("ynab");
-      throw ToolError.auth(
-        "YNAB requires an app update (426). The session has been cleared \u2014 please reload the YNAB tab and try again."
-      );
-    }
-    if (response.status === 429) {
-      const retryAfter = response.headers.get("Retry-After");
-      const retryMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
-      throw ToolError.rateLimited(`Rate limited: ${context} \u2014 ${errorBody}`, retryMs);
-    }
-    if (response.status === 401 || response.status === 403) {
-      clearAuthCache("ynab");
-      throw ToolError.auth(`Auth error (${response.status}): ${errorBody}`);
-    }
-    if (response.status === 404) throw ToolError.notFound(`Not found: ${context} \u2014 ${errorBody}`);
-    if (response.status === 422) throw ToolError.validation(`Validation error: ${context} \u2014 ${errorBody}`);
-    throw ToolError.internal(`API error (${response.status}): ${context} \u2014 ${errorBody}`);
-  };
-  var catalog = async (operationName, requestData = {}) => {
-    const headers = getHeaders();
-    headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";
-    let response;
-    try {
-      response = await fetch("/api/v1/catalog", {
-        method: "POST",
-        headers,
-        credentials: "include",
-        body: `operation_name=${encodeURIComponent(operationName)}&request_data=${encodeURIComponent(JSON.stringify(requestData))}`,
-        signal: AbortSignal.timeout(3e4)
-      });
-    } catch (err2) {
-      if (err2 instanceof DOMException && err2.name === "TimeoutError")
-        throw ToolError.timeout(`Catalog request timed out: ${operationName}`);
-      if (err2 instanceof DOMException && err2.name === "AbortError") throw new ToolError("Request was aborted", "aborted");
-      throw new ToolError(`Network error: ${err2 instanceof Error ? err2.message : String(err2)}`, "network_error", {
-        category: "internal",
-        retryable: true
-      });
-    }
-    if (!response.ok) return handleApiError(response, operationName);
-    const data = await response.json();
-    if (data.error) {
-      throw ToolError.internal(`Catalog error (${operationName}): ${data.error.message}`);
-    }
-    return data;
-  };
-  var BUDGET_SCHEMA_VERSION = 41;
-  var syncBudget = async (planId) => catalog("syncBudgetData", {
-    budget_version_id: planId,
-    sync_type: "delta",
-    starting_device_knowledge: 0,
-    ending_device_knowledge: 0,
-    device_knowledge_of_server: 0,
-    calculated_entities_included: false,
-    schema_version: BUDGET_SCHEMA_VERSION,
-    schema_version_of_knowledge: BUDGET_SCHEMA_VERSION,
-    changed_entities: {}
-  });
-  var syncWrite = async (planId, changedEntities) => {
-    const readResult = await syncBudget(planId);
-    const serverKnowledge = readResult.current_server_knowledge ?? 0;
-    return catalog("syncBudgetData", {
-      budget_version_id: planId,
-      sync_type: "delta",
-      starting_device_knowledge: 0,
-      ending_device_knowledge: 1,
-      device_knowledge_of_server: serverKnowledge,
-      calculated_entities_included: false,
-      schema_version: BUDGET_SCHEMA_VERSION,
-      schema_version_of_knowledge: BUDGET_SCHEMA_VERSION,
-      changed_entities: changedEntities
-    });
-  };
-  var api = async (endpoint, options = {}) => {
-    const headers = getHeaders();
-    let fetchBody;
-    if (options.body) {
-      headers["Content-Type"] = "application/json";
-      fetchBody = JSON.stringify(options.body);
-    }
-    let response;
-    try {
-      response = await fetch(`/api/v2${endpoint}`, {
-        method: options.method ?? "GET",
-        headers,
-        body: fetchBody,
-        credentials: "include",
-        signal: AbortSignal.timeout(3e4)
-      });
-    } catch (err2) {
-      if (err2 instanceof DOMException && err2.name === "TimeoutError")
-        throw ToolError.timeout(`API request timed out: ${endpoint}`);
-      if (err2 instanceof DOMException && err2.name === "AbortError") throw new ToolError("Request was aborted", "aborted");
-      throw new ToolError(`Network error: ${err2 instanceof Error ? err2.message : String(err2)}`, "network_error", {
-        category: "internal",
-        retryable: true
-      });
-    }
-    if (!response.ok) return handleApiError(response, endpoint);
-    if (response.status === 204) return {};
-    return await response.json();
-  };
-
   // node_modules/zod/v4/classic/external.js
   var external_exports = {};
   __export(external_exports, {
@@ -14253,19 +14097,214 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   // node_modules/zod/v4/classic/external.js
   config(en_default());
 
-  // src/tools/schemas.ts
-  var formatMilliunits = (milliunits) => {
-    const amount = milliunits / 1e3;
-    return amount.toFixed(2);
+  // src/ynab-api.ts
+  var NOT_AUTHENTICATED_MESSAGE = "Not authenticated \u2014 please log in to YNAB.";
+  var generateDeviceId = () => crypto.randomUUID();
+  var extractPlanId = () => {
+    const url2 = getCurrentUrl();
+    const match = url2.match(/app\.ynab\.com\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/);
+    return match?.[1] ?? null;
   };
-  var userSchema = external_exports.object({
-    id: external_exports.string().describe("User ID"),
-    first_name: external_exports.string().describe("First name"),
-    email: external_exports.string().describe("Email address")
+  var getAuth = () => {
+    const cached2 = getAuthCache("ynab");
+    if (cached2?.sessionToken && cached2.planId) return cached2;
+    const sessionToken = getMetaContent("session-token");
+    if (!sessionToken) return null;
+    const user = getPageGlobal("YNAB_CLIENT_CONSTANTS.USER");
+    if (!user?.id) return null;
+    const planId = extractPlanId();
+    if (!planId) return null;
+    const deviceId = cached2?.deviceId ?? generateDeviceId();
+    const auth = {
+      sessionToken,
+      deviceId,
+      userId: user.id,
+      planId
+    };
+    setAuthCache("ynab", auth);
+    return auth;
+  };
+  var isAuthenticated = () => getAuth() !== null;
+  var waitForAuth = () => waitUntil(() => isAuthenticated(), { interval: 500, timeout: 5e3 }).then(
+    () => true,
+    () => false
+  );
+  var getPlanId = () => {
+    const auth = getAuth();
+    if (!auth) throw ToolError.auth(NOT_AUTHENTICATED_MESSAGE);
+    return auth.planId;
+  };
+  var getDeviceId = () => {
+    const auth = getAuth();
+    if (!auth) throw ToolError.auth(NOT_AUTHENTICATED_MESSAGE);
+    return auth.deviceId;
+  };
+  var getUserId = () => {
+    const auth = getAuth();
+    if (!auth) throw ToolError.auth(NOT_AUTHENTICATED_MESSAGE);
+    return auth.userId;
+  };
+  var assertAuthenticated = () => {
+    if (!getAuth()) throw ToolError.auth(NOT_AUTHENTICATED_MESSAGE);
+  };
+  var getHeaders = () => {
+    const auth = getAuth();
+    if (!auth) throw ToolError.auth(NOT_AUTHENTICATED_MESSAGE);
+    const appVersion = getPageGlobal("YNAB_CLIENT_CONSTANTS.YNAB_APP_VERSION");
+    const headers = {
+      "X-Session-Token": auth.sessionToken,
+      "X-YNAB-Device-Id": auth.deviceId,
+      "X-YNAB-Device-OS": "web",
+      "X-Requested-With": "XMLHttpRequest",
+      Accept: "application/json, text/javascript, */*; q=0.01"
+    };
+    if (appVersion) headers["X-YNAB-Device-App-Version"] = appVersion;
+    return headers;
+  };
+  var handleApiError = async (response, context) => {
+    const errorBody = (await response.text().catch(() => "")).substring(0, 512);
+    if (response.status === 426) {
+      clearAuthCache("ynab");
+      throw ToolError.auth(
+        "YNAB requires an app update (426). The session has been cleared \u2014 please reload the YNAB tab and try again."
+      );
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retryMs = retryAfter !== null ? parseRetryAfterMs(retryAfter) : void 0;
+      throw ToolError.rateLimited(`Rate limited: ${context} \u2014 ${errorBody}`, retryMs);
+    }
+    if (response.status === 401 || response.status === 403) {
+      clearAuthCache("ynab");
+      throw ToolError.auth(`Auth error (${response.status}): ${errorBody}`);
+    }
+    if (response.status === 404) throw ToolError.notFound(`Not found: ${context} \u2014 ${errorBody}`);
+    if (response.status === 422) throw ToolError.validation(`Validation error: ${context} \u2014 ${errorBody}`);
+    throw ToolError.internal(`API error (${response.status}): ${context} \u2014 ${errorBody}`);
+  };
+  var handleNetworkError = (err2, context) => {
+    if (err2 instanceof DOMException && err2.name === "TimeoutError")
+      throw ToolError.timeout(`Request timed out: ${context}`);
+    if (err2 instanceof DOMException && err2.name === "AbortError") throw new ToolError("Request was aborted", "aborted");
+    throw new ToolError(`Network error: ${err2 instanceof Error ? err2.message : String(err2)}`, "network_error", {
+      category: "internal",
+      retryable: true
+    });
+  };
+  var catalog = async (operationName, requestData = {}) => {
+    const headers = getHeaders();
+    headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";
+    let response;
+    try {
+      response = await fetch("/api/v1/catalog", {
+        method: "POST",
+        headers,
+        credentials: "include",
+        body: `operation_name=${encodeURIComponent(operationName)}&request_data=${encodeURIComponent(JSON.stringify(requestData))}`,
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (err2) {
+      return handleNetworkError(err2, operationName);
+    }
+    if (!response.ok) return handleApiError(response, operationName);
+    const data = await response.json();
+    if (data.error) {
+      throw ToolError.internal(`Catalog error (${operationName}): ${data.error.message}`);
+    }
+    return data;
+  };
+  var BUDGET_SCHEMA_VERSION = 41;
+  var syncBudget = async (planId) => catalog("syncBudgetData", {
+    budget_version_id: planId,
+    sync_type: "delta",
+    starting_device_knowledge: 0,
+    ending_device_knowledge: 0,
+    device_knowledge_of_server: 0,
+    calculated_entities_included: false,
+    schema_version: BUDGET_SCHEMA_VERSION,
+    schema_version_of_knowledge: BUDGET_SCHEMA_VERSION,
+    changed_entities: {}
   });
-  var planSchema = external_exports.object({
-    id: external_exports.string().describe("Plan (budget version) ID used in API calls"),
-    budget_id: external_exports.string().describe("Underlying budget ID"),
+  var syncWrite = async (planId, changedEntities, serverKnowledge) => {
+    const knowledge = serverKnowledge ?? (await syncBudget(planId)).current_server_knowledge ?? 0;
+    return catalog("syncBudgetData", {
+      budget_version_id: planId,
+      sync_type: "delta",
+      starting_device_knowledge: 0,
+      ending_device_knowledge: 1,
+      device_knowledge_of_server: knowledge,
+      calculated_entities_included: false,
+      schema_version: BUDGET_SCHEMA_VERSION,
+      schema_version_of_knowledge: BUDGET_SCHEMA_VERSION,
+      changed_entities: changedEntities
+    });
+  };
+  var api = async (endpoint, options = {}) => {
+    const headers = getHeaders();
+    let fetchBody;
+    if (options.body) {
+      headers["Content-Type"] = "application/json";
+      fetchBody = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(`/api/v2${endpoint}`, {
+        method: options.method ?? "GET",
+        headers,
+        body: fetchBody,
+        credentials: "include",
+        signal: AbortSignal.timeout(3e4)
+      });
+    } catch (err2) {
+      return handleNetworkError(err2, endpoint);
+    }
+    if (!response.ok) return handleApiError(response, endpoint);
+    if (response.status === 204) return {};
+    return await response.json();
+  };
+
+  // src/tools/schemas.ts
+  var formatMilliunits = (milliunits) => {
+    const amount = milliunits / 1e3;
+    return amount.toFixed(2);
+  };
+  var toMilliunits = (amount) => Math.round(amount * 1e3);
+  var notTombstone = (x) => !x.is_tombstone;
+  var findCategory = (entities, id) => {
+    const c = (entities?.be_subcategories ?? []).find((s) => s.id === id && notTombstone(s));
+    if (!c) throw ToolError.notFound(`Category not found: ${id}`);
+    return c;
+  };
+  var findCategoryGroup = (entities, id) => {
+    const g = (entities?.be_master_categories ?? []).find((m) => m.id === id && notTombstone(m));
+    if (!g) throw ToolError.notFound(`Category group not found: ${id}`);
+    return g;
+  };
+  var assertCategoryGroupDeletable = (group) => {
+    if (group.deletable !== true) {
+      throw ToolError.validation(`Category group "${group.name}" is not deletable.`);
+    }
+  };
+  var assertCategoryDeletable = (category) => {
+    if (category.entities_account_id != null || category.type !== CATEGORY_TYPE_DEFAULT) {
+      throw ToolError.validation(`Category "${category.name}" is system-managed and cannot be deleted.`);
+    }
+  };
+  var nextTopSortableIndex = (rows, step = 10) => {
+    let min = 0;
+    for (const r of rows) {
+      if (typeof r.sortable_index === "number" && r.sortable_index < min) min = r.sortable_index;
+    }
+    return min - step;
+  };
+  var userSchema = external_exports.object({
+    id: external_exports.string().describe("User ID"),
+    first_name: external_exports.string().describe("First name"),
+    email: external_exports.string().describe("Email address")
+  });
+  var planSchema = external_exports.object({
+    id: external_exports.string().describe("Plan (budget version) ID used in API calls"),
+    budget_id: external_exports.string().describe("Underlying budget ID"),
     name: external_exports.string().describe("Plan name"),
     date_format: external_exports.string().describe("Date format string (e.g. MM/DD/YYYY)"),
     currency_symbol: external_exports.string().describe("Currency symbol (e.g. $)"),
@@ -14317,7 +14356,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     cleared: external_exports.string().describe("Cleared status: cleared, uncleared, or reconciled"),
     approved: external_exports.boolean().describe("Whether the transaction is approved"),
     flag_color: external_exports.string().describe("Flag color or empty string"),
-    flag_name: external_exports.string().describe("Custom flag name or empty string"),
     account_id: external_exports.string().describe("Account ID"),
     account_name: external_exports.string().describe("Account name"),
     payee_id: external_exports.string().describe("Payee ID"),
@@ -14325,7 +14363,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     category_id: external_exports.string().describe("Category ID"),
     category_name: external_exports.string().describe("Category name"),
     transfer_account_id: external_exports.string().describe("If a transfer, the destination account ID"),
-    import_id: external_exports.string().describe("Import ID for deduplication"),
+    imported_payee: external_exports.string().describe("Bank-imported payee name after YNAB cleansing (empty if manually entered)"),
+    original_imported_payee: external_exports.string().describe("Raw payee string from the bank feed before any cleansing (empty if manually entered)"),
     deleted: external_exports.boolean().describe("Whether the transaction is deleted")
   });
   var subtransactionSchema = external_exports.object({
@@ -14351,7 +14390,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     budgeted_milliunits: external_exports.number().describe("Total budgeted in milliunits"),
     activity_milliunits: external_exports.number().describe("Total activity in milliunits"),
     to_be_budgeted_milliunits: external_exports.number().describe("Ready to Assign in milliunits"),
-    age_of_money: external_exports.number().describe("Age of money in days")
+    age_of_money: external_exports.number().nullable().describe("Age of money in days, or null if not yet computed")
   });
   var scheduledTransactionSchema = external_exports.object({
     id: external_exports.string().describe("Scheduled transaction ID"),
@@ -14372,6 +14411,256 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     category_name: external_exports.string().describe("Category name"),
     deleted: external_exports.boolean().describe("Whether the scheduled transaction is deleted")
   });
+  var MONEY_MOVEMENT_SOURCE = {
+    /** RTA ↔ category (in either direction). */
+    ASSIGN: "manual_assign",
+    /** Category-to-category transfer. */
+    MOVEMENT: "manual_movement"
+  };
+  var GOAL_TYPE = {
+    /** "Set aside" or "Refill" — `goal_needs_whole_amount` differentiates. */
+    NEED: "NEED",
+    /** "Have a balance of" — no date, no cadence. */
+    TARGET_BALANCE: "TB",
+    /** "Have a balance of by date" — one-shot with `goal_target_date`. */
+    TARGET_BY_DATE: "TBD",
+    /** Debt payment goals on debt-account categories. */
+    DEBT: "DEBT",
+    /** Legacy "Monthly Funding". The modern UI no longer creates these but they
+        still exist on older categories and the API still honors them. */
+    MONTHLY_FUNDING: "MF"
+  };
+  var CATEGORY_TYPE_DEFAULT = "DFT";
+  var SUBCATEGORY_BUDGET_PREFIX = "mcb";
+  var MONTHLY_BUDGET_PREFIX = "mb";
+  var toMonthKey = (month) => month.substring(0, 7);
+  var currentMonthKey = () => {
+    const now = /* @__PURE__ */ new Date();
+    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+  };
+  var formatSubcategoryBudgetId = (monthKey, categoryId) => `${SUBCATEGORY_BUDGET_PREFIX}/${monthKey}/${categoryId}`;
+  var formatMonthlyBudgetId = (monthKey, planId) => `${MONTHLY_BUDGET_PREFIX}/${monthKey}/${planId}`;
+  var CLEARED_MAP = {
+    cleared: "Cleared",
+    uncleared: "Uncleared",
+    reconciled: "Reconciled"
+  };
+  var FLAG_MAP = {
+    red: "Red",
+    orange: "Orange",
+    yellow: "Yellow",
+    green: "Green",
+    blue: "Blue",
+    purple: "Purple"
+  };
+  var cadenceWireValue = {
+    weekly: 2,
+    monthly: 1,
+    yearly: 13
+  };
+  var isValidCalendarDate = (s) => {
+    const parts = s.split("-").map(Number);
+    const year = parts[0] ?? 0;
+    const month = parts[1] ?? 0;
+    const day = parts[2] ?? 0;
+    if (month < 1 || month > 12) return false;
+    const maxDay = new Date(year, month, 0).getDate();
+    return day >= 1 && day <= maxDay;
+  };
+  var needGoalShape = {
+    target: external_exports.number().positive().describe("Goal amount in currency units (e.g. 50 for $50)"),
+    cadence: external_exports.enum(["weekly", "monthly", "yearly"]).optional().describe("How often the goal recurs. Defaults to monthly."),
+    every: external_exports.number().int().min(1).optional().describe("Multiplier on cadence (e.g. cadence=monthly + every=5 means every 5 months). Defaults to 1."),
+    day: external_exports.number().int().min(0).max(31).optional().describe("Day-of-week (0=Sunday, 6=Saturday) for weekly cadence, or day-of-month (1-31) for monthly cadence."),
+    start_date: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD").refine(isValidCalendarDate, "Date must be a valid calendar date").optional().describe("First occurrence date (YYYY-MM-DD). Required for yearly cadence; optional for others.")
+  };
+  var yearlyNeedRefine = (data, ctx) => {
+    if (data.cadence === "yearly" && !data.start_date) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: 'start_date is required when cadence is "yearly"',
+        path: ["start_date"]
+      });
+    }
+  };
+  var needCadenceDayRefine = (data, ctx) => {
+    if (data.day === void 0) return;
+    const cadence = data.cadence ?? "monthly";
+    if (cadence === "weekly" && (data.day < 0 || data.day > 6)) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "For weekly cadence, day must be 0\u20136 (0=Sunday, 6=Saturday)",
+        path: ["day"]
+      });
+    } else if (cadence === "monthly" && (data.day < 1 || data.day > 31)) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "For monthly cadence, day must be 1\u201331",
+        path: ["day"]
+      });
+    } else if (cadence === "yearly") {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        message: "For yearly cadence, use start_date to set the recurrence anchor instead of day",
+        path: ["day"]
+      });
+    }
+  };
+  var goalSpecSchema = external_exports.discriminatedUnion("type", [
+    external_exports.object({ type: external_exports.literal("set_aside"), ...needGoalShape }).strict().superRefine(yearlyNeedRefine).superRefine(needCadenceDayRefine),
+    external_exports.object({ type: external_exports.literal("refill"), ...needGoalShape }).strict().superRefine(yearlyNeedRefine).superRefine(needCadenceDayRefine),
+    external_exports.object({
+      type: external_exports.literal("target_balance"),
+      target: external_exports.number().positive().describe("Balance to maintain in currency units")
+    }).strict(),
+    external_exports.object({
+      type: external_exports.literal("target_by_date"),
+      target: external_exports.number().positive().describe("Target balance to have by the given date in currency units"),
+      date: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be YYYY-MM-DD").refine(isValidCalendarDate, "Date must be a valid calendar date").describe("Target date YYYY-MM-DD")
+    }).strict(),
+    external_exports.object({
+      type: external_exports.literal("debt"),
+      target: external_exports.number().positive().describe("Monthly payment amount in currency units"),
+      day: external_exports.number().int().min(1).max(31).optional().describe("Day of month the payment is due (1-31). Defaults to 1.")
+    }).strict(),
+    external_exports.object({ type: external_exports.literal("none") }).strict()
+  ]);
+  var NO_GOAL_FIELDS = {
+    goal_type: null,
+    goal_created_on: null,
+    goal_needs_whole_amount: null,
+    goal_target_amount: 0,
+    goal_target_date: null,
+    goal_cadence: null,
+    goal_cadence_frequency: null,
+    goal_day: null
+  };
+  var buildGoalFields = (goal) => {
+    if (!goal || goal.type === "none") return { ...NO_GOAL_FIELDS };
+    const now = /* @__PURE__ */ new Date();
+    const createdOn = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+    const base = { ...NO_GOAL_FIELDS, goal_created_on: createdOn };
+    switch (goal.type) {
+      case "set_aside":
+      case "refill": {
+        const cadence = goal.cadence ?? "monthly";
+        return {
+          ...base,
+          goal_type: GOAL_TYPE.NEED,
+          goal_needs_whole_amount: goal.type === "set_aside",
+          goal_target_amount: toMilliunits(goal.target),
+          goal_cadence: cadenceWireValue[cadence],
+          goal_cadence_frequency: goal.every ?? 1,
+          goal_day: cadence === "yearly" ? null : goal.day ?? null,
+          goal_target_date: goal.start_date ?? null
+        };
+      }
+      case "target_balance":
+        return { ...base, goal_type: GOAL_TYPE.TARGET_BALANCE, goal_target_amount: toMilliunits(goal.target) };
+      case "target_by_date":
+        return {
+          ...base,
+          goal_type: GOAL_TYPE.TARGET_BY_DATE,
+          goal_target_amount: toMilliunits(goal.target),
+          goal_target_date: goal.date
+        };
+      case "debt":
+        return {
+          ...base,
+          goal_type: GOAL_TYPE.DEBT,
+          goal_target_amount: toMilliunits(goal.target),
+          goal_cadence: cadenceWireValue.monthly,
+          goal_cadence_frequency: 1,
+          goal_day: goal.day ?? 1
+        };
+    }
+  };
+  var resolvePayee = (existingPayees, payeeName) => {
+    const target = payeeName.toLowerCase();
+    const match = existingPayees.find((p) => notTombstone(p) && p.name?.toLowerCase() === target);
+    if (match?.id) return { payeeId: match.id };
+    const payeeId = crypto.randomUUID();
+    const newPayee = {
+      id: payeeId,
+      is_tombstone: false,
+      entities_account_id: null,
+      enabled: true,
+      auto_fill_subcategory_id: null,
+      auto_fill_memo: null,
+      auto_fill_amount: 0,
+      auto_fill_subcategory_enabled: true,
+      auto_fill_memo_enabled: false,
+      auto_fill_amount_enabled: false,
+      rename_on_import_enabled: true,
+      name: payeeName,
+      internal_name: null
+    };
+    return { payeeId, newPayee };
+  };
+  var buildAccountCalcMap = (entities) => new Map(
+    (entities.be_account_calculations ?? []).filter((c) => c.entities_account_id).map((c) => [c.entities_account_id, c])
+  );
+  var buildMonthlyBudgetCalcMap = (calcs) => {
+    const map2 = /* @__PURE__ */ new Map();
+    for (const calc of calcs) {
+      const entityId = calc.entities_monthly_budget_id;
+      if (!entityId) continue;
+      const parts = entityId.split("/");
+      const month = parts[1];
+      if (parts.length >= 2 && month) map2.set(month, calc);
+    }
+    return map2;
+  };
+  var subcategoryCalcKey = (month, categoryId) => `${month}/${categoryId}`;
+  var parseSubcategoryEntityId = (entityId) => {
+    if (!entityId) return null;
+    const parts = entityId.split("/");
+    if (parts.length !== 3) return null;
+    const [, month, categoryId] = parts;
+    if (!month || !categoryId) return null;
+    return { month, categoryId };
+  };
+  var buildSubcategoryCalcMap = (calcs) => {
+    const map2 = /* @__PURE__ */ new Map();
+    for (const calc of calcs) {
+      const parsed = parseSubcategoryEntityId(calc.entities_monthly_subcategory_budget_id);
+      if (parsed) map2.set(subcategoryCalcKey(parsed.month, parsed.categoryId), calc);
+    }
+    return map2;
+  };
+  var buildSubcategoryBudgetMap = (budgets) => {
+    const map2 = /* @__PURE__ */ new Map();
+    for (const budget of budgets) {
+      if (budget.is_tombstone) continue;
+      const parsed = parseSubcategoryEntityId(budget.id);
+      if (parsed) map2.set(subcategoryCalcKey(parsed.month, parsed.categoryId), budget);
+    }
+    return map2;
+  };
+  var mapCategoryForMonth = (c, budgetMap, calcMap, month) => {
+    const key = subcategoryCalcKey(month, c.id ?? "");
+    const budget = budgetMap.get(key);
+    const calc = calcMap.get(key);
+    return mapCategory({
+      ...c,
+      budgeted: budget?.budgeted ?? c.budgeted,
+      activity: (calc?.cash_outflows ?? 0) + (calc?.credit_outflows ?? 0),
+      balance: calc?.balance ?? c.balance,
+      goal_percentage_complete: calc?.goal_percentage_complete ?? c.goal_percentage_complete
+    });
+  };
+  var hasId = (x) => !!x.id;
+  var buildLookups = (entities) => ({
+    payees: new Map(
+      (entities.be_payees ?? []).filter(notTombstone).filter(hasId).map((p) => [p.id, p.name ?? ""])
+    ),
+    accounts: new Map(
+      (entities.be_accounts ?? []).filter(notTombstone).filter(hasId).map((a) => [a.id, a.account_name ?? ""])
+    ),
+    categories: new Map(
+      (entities.be_subcategories ?? []).filter(notTombstone).filter(hasId).map((c) => [c.id, c.name ?? ""])
+    )
+  });
   var mapUser = (u) => ({
     id: u.id ?? "",
     first_name: u.first_name ?? "",
@@ -14386,8 +14675,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         const df = JSON.parse(p.date_format);
         dateFormat = df.format ?? "";
       }
-    } catch {
-      dateFormat = p.date_format ?? "";
+    } catch (err2) {
+      log.warn("mapPlan: failed to parse date_format", { raw: p.date_format, err: err2 });
     }
     try {
       if (p.currency_format) {
@@ -14395,7 +14684,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         currencySymbol = cf.currency_symbol ?? "$";
         currencyIsoCode = cf.iso_code ?? "USD";
       }
-    } catch {
+    } catch (err2) {
+      log.warn("mapPlan: failed to parse currency_format", { raw: p.currency_format, err: err2 });
     }
     return {
       id: p.id ?? "",
@@ -14435,7 +14725,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     activity_milliunits: c.activity ?? 0,
     balance_milliunits: c.balance ?? 0,
     goal_type: c.goal_type ?? "",
-    goal_target: formatMilliunits(c.goal_target ?? 0),
+    // The "goal target" the user configured is stored on the category itself:
+    // - MF (legacy Monthly Funding): the static target lives in `monthly_funding`
+    // - All modern goal types (NEED, TB, TBD, DEBT): use `goal_target_amount`
+    // The calc's `goal_target` is YNAB's dynamically-computed "needed this month",
+    // which for refill goals returns max(0, target - current_balance) — surprising
+    // and not what users mean when they ask for the goal target.
+    goal_target: formatMilliunits(
+      (c.goal_type === GOAL_TYPE.MONTHLY_FUNDING ? c.monthly_funding : c.goal_target_amount) ?? 0
+    ),
     goal_percentage_complete: c.goal_percentage_complete ?? 0
   });
   var mapPayee = (p) => ({
@@ -14443,36 +14741,36 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     name: p.name ?? "",
     transfer_account_id: p.entities_account_id ?? ""
   });
-  var mapTransaction = (t) => ({
+  var mapTransaction = (t, lookups) => ({
     id: t.id ?? "",
     date: t.date ?? "",
     amount: formatMilliunits(t.amount ?? 0),
     amount_milliunits: t.amount ?? 0,
     memo: t.memo ?? "",
-    cleared: t.cleared ?? "uncleared",
-    approved: t.approved ?? false,
-    flag_color: t.flag_color ?? "",
-    flag_name: t.flag_name ?? "",
+    cleared: t.cleared?.toLowerCase() ?? "uncleared",
+    approved: t.accepted ?? false,
+    flag_color: t.flag?.toLowerCase() ?? "",
     account_id: t.entities_account_id ?? "",
-    account_name: t.account_name ?? "",
+    account_name: lookups?.accounts.get(t.entities_account_id ?? "") ?? "",
     payee_id: t.entities_payee_id ?? "",
-    payee_name: t.payee_name ?? "",
+    payee_name: lookups?.payees.get(t.entities_payee_id ?? "") ?? "",
     category_id: t.entities_subcategory_id ?? "",
-    category_name: t.category_name ?? "",
+    category_name: lookups?.categories.get(t.entities_subcategory_id ?? "") ?? "",
     transfer_account_id: t.transfer_account_id ?? "",
-    import_id: t.import_id ?? "",
+    imported_payee: t.imported_payee ?? "",
+    original_imported_payee: t.original_imported_payee ?? "",
     deleted: t.is_tombstone === true
   });
-  var mapSubtransaction = (s) => ({
+  var mapSubtransaction = (s, lookups) => ({
     id: s.id ?? "",
     transaction_id: s.entities_transaction_id ?? "",
     amount: formatMilliunits(s.amount ?? 0),
     amount_milliunits: s.amount ?? 0,
     memo: s.memo ?? "",
     payee_id: s.entities_payee_id ?? "",
-    payee_name: s.payee_name ?? "",
+    payee_name: lookups?.payees.get(s.entities_payee_id ?? "") ?? "",
     category_id: s.entities_subcategory_id ?? "",
-    category_name: s.category_name ?? "",
+    category_name: lookups?.categories.get(s.entities_subcategory_id ?? "") ?? "",
     transfer_account_id: s.transfer_account_id ?? "",
     deleted: s.is_tombstone === true
   });
@@ -14491,87 +14789,331 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       budgeted_milliunits: budgeted,
       activity_milliunits: activity,
       to_be_budgeted_milliunits: toBeBudgeted,
-      age_of_money: calc?.age_of_money ?? 0
+      age_of_money: calc?.age_of_money ?? null
     };
   };
-  var mapScheduledTransaction = (s) => ({
+  var mapScheduledTransaction = (s, lookups) => ({
     id: s.id ?? "",
-    date_first: s.date_first ?? "",
-    date_next: s.date_next ?? "",
+    date_first: s.date ?? "",
+    date_next: s.upcoming_instances?.[0] ?? s.date ?? "",
     frequency: s.frequency ?? "never",
     amount: formatMilliunits(s.amount ?? 0),
     amount_milliunits: s.amount ?? 0,
     memo: s.memo ?? "",
-    flag_color: s.flag_color ?? "",
+    flag_color: s.flag?.toLowerCase() ?? "",
     account_id: s.entities_account_id ?? "",
-    account_name: s.account_name ?? "",
+    account_name: lookups?.accounts.get(s.entities_account_id ?? "") ?? "",
     payee_id: s.entities_payee_id ?? "",
-    payee_name: s.payee_name ?? "",
+    payee_name: lookups?.payees.get(s.entities_payee_id ?? "") ?? "",
     category_id: s.entities_subcategory_id ?? "",
-    category_name: s.category_name ?? "",
+    category_name: lookups?.categories.get(s.entities_subcategory_id ?? "") ?? "",
     deleted: s.is_tombstone === true
   });
 
-  // src/tools/get-current-user.ts
-  var getCurrentUser = defineTool({
-    name: "get_current_user",
-    displayName: "Get Current User",
-    description: "Get the profile of the currently authenticated YNAB user including name and email.",
-    summary: "Get your YNAB user profile",
-    icon: "user",
-    group: "Account",
-    input: external_exports.object({}),
-    output: external_exports.object({ user: userSchema }),
-    handle: async () => {
-      const data = await api("/user");
-      return { user: mapUser(data) };
+  // src/tools/create-category.ts
+  var createCategory = defineTool({
+    name: "create_category",
+    displayName: "Create Category",
+    description: 'Create a new category in an existing category group. Optionally set an initial goal: "set_aside" (set aside X per cadence), "refill" (refill the balance up to X per cadence), "target_balance" (have a balance of X), or "target_by_date" (have a balance of X by a specific date). NEED-style goals (set_aside, refill) accept weekly/monthly/yearly cadence. Debt goals are not supported for new categories \u2014 they only apply to existing debt-account categories.',
+    summary: "Create a new budget category",
+    icon: "plus",
+    group: "Categories",
+    input: external_exports.object({
+      group_id: external_exports.string().min(1).describe("Category group ID to create the category in"),
+      name: external_exports.string().min(1).describe("Name of the new category"),
+      goal: goalSpecSchema.optional().describe("Optional initial goal for the category"),
+      note: external_exports.string().optional().describe("Optional note for the category")
+    }),
+    output: external_exports.object({
+      category: categorySchema
+    }),
+    handle: async (params) => {
+      if (params.goal?.type === "debt") {
+        throw ToolError.validation("Debt goals can only be set on debt-account categories.");
+      }
+      const planId = getPlanId();
+      const categoryId = crypto.randomUUID();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      assertCategoryGroupDeletable(findCategoryGroup(budget.changed_entities, params.group_id));
+      const childCategories = (budget.changed_entities?.be_subcategories ?? []).filter(
+        (c) => c.entities_master_category_id === params.group_id
+      );
+      const monthKey = currentMonthKey();
+      const categoryEntry = {
+        id: categoryId,
+        is_tombstone: false,
+        entities_master_category_id: params.group_id,
+        entities_account_id: null,
+        internal_name: null,
+        sortable_index: nextTopSortableIndex(childCategories, 5),
+        name: params.name,
+        type: CATEGORY_TYPE_DEFAULT,
+        note: params.note ?? null,
+        monthly_funding: 0,
+        is_hidden: false,
+        pinned_index: null,
+        pinned_goal_index: null,
+        ...buildGoalFields(params.goal)
+      };
+      const budgetEntry = {
+        id: formatSubcategoryBudgetId(monthKey, categoryId),
+        is_tombstone: false,
+        entities_monthly_budget_id: formatMonthlyBudgetId(monthKey, planId),
+        entities_subcategory_id: categoryId,
+        budgeted: 0
+      };
+      await syncWrite(
+        planId,
+        {
+          be_subcategories: [categoryEntry],
+          be_monthly_subcategory_budgets: [budgetEntry]
+        },
+        serverKnowledge
+      );
+      return { category: mapCategory(categoryEntry) };
     }
   });
 
-  // src/tools/get-plan.ts
-  var getPlan = defineTool({
-    name: "get_plan",
-    displayName: "Get Plan",
-    description: "Get details about the currently active YNAB plan (budget), including name, currency, and date format. The plan ID is extracted from the current URL.",
-    summary: "Get the active plan details",
-    icon: "wallet",
-    group: "Plans",
-    input: external_exports.object({}),
-    output: external_exports.object({ plan: planSchema }),
-    handle: async () => {
+  // src/tools/create-category-group.ts
+  var createCategoryGroup = defineTool({
+    name: "create_category_group",
+    displayName: "Create Category Group",
+    description: "Create a new category group in the active YNAB plan.",
+    summary: "Create a category group",
+    icon: "folder-plus",
+    group: "Categories",
+    input: external_exports.object({
+      name: external_exports.string().min(1).describe("Name of the new category group")
+    }),
+    output: external_exports.object({
+      group: categoryGroupSchema
+    }),
+    handle: async (params) => {
       const planId = getPlanId();
-      const result = await catalog("getInitialUserData", {
-        device_info: { id: planId, device_os: "web" }
-      });
-      return { plan: mapPlan(result.budget_version) };
+      const groupId = crypto.randomUUID();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const groupEntry = {
+        id: groupId,
+        is_tombstone: false,
+        internal_name: "",
+        deletable: true,
+        sortable_index: nextTopSortableIndex(budget.changed_entities?.be_master_categories ?? []),
+        name: params.name,
+        note: "",
+        is_hidden: false
+      };
+      await syncWrite(planId, { be_master_categories: [groupEntry] }, serverKnowledge);
+      return { group: mapCategoryGroup(groupEntry) };
     }
   });
 
-  // src/tools/list-accounts.ts
-  var listAccounts = defineTool({
-    name: "list_accounts",
-    displayName: "List Accounts",
-    description: "List all accounts in the active YNAB plan. Returns account name, type, balances, and on-budget status. Includes checking, savings, credit cards, and tracking accounts.",
-    summary: "List all budget accounts",
-    icon: "landmark",
-    group: "Accounts",
+  // src/tools/create-transaction.ts
+  var createTransaction = defineTool({
+    name: "create_transaction",
+    displayName: "Create Transaction",
+    description: "Create a new transaction in the active YNAB plan. Amount is in currency units (e.g. -42.50 for a $42.50 expense, 1500 for $1500 income). Negative amounts are outflows (expenses), positive amounts are inflows (income).",
+    summary: "Create a new transaction",
+    icon: "plus",
+    group: "Transactions",
     input: external_exports.object({
-      include_closed: external_exports.boolean().optional().describe("Include closed accounts (default false)")
+      account_id: external_exports.string().min(1).describe("Account ID to create the transaction in"),
+      date: external_exports.string().min(1).describe("Transaction date in YYYY-MM-DD format"),
+      amount: external_exports.number().describe(
+        "Amount in currency units (negative for expenses, positive for income). E.g. -42.50 for a $42.50 expense."
+      ),
+      payee_name: external_exports.string().optional().describe("Payee name (creates new payee if not found)"),
+      payee_id: external_exports.string().optional().describe("Existing payee ID (takes precedence over payee_name)"),
+      category_id: external_exports.string().optional().describe("Category ID to assign"),
+      memo: external_exports.string().optional().describe("Transaction memo"),
+      cleared: external_exports.enum(["cleared", "uncleared", "reconciled"]).optional().describe("Cleared status (default uncleared)"),
+      approved: external_exports.boolean().optional().describe("Whether the transaction is approved (default true)"),
+      flag_color: external_exports.enum(["red", "orange", "yellow", "green", "blue", "purple"]).optional().describe("Flag color")
     }),
     output: external_exports.object({
-      accounts: external_exports.array(accountSchema).describe("List of accounts")
+      transaction: transactionSchema
     }),
     handle: async (params) => {
       const planId = getPlanId();
-      const result = await syncBudget(planId);
-      const entities = result.changed_entities;
-      const raw = entities?.be_accounts ?? [];
-      const calcMap = new Map((entities?.be_account_calculations ?? []).map((c) => [c.entities_account_id, c]));
-      let accounts = raw.filter((a) => !a.is_tombstone).map((a) => mapAccount(a, calcMap.get(a.id)));
-      if (!params.include_closed) {
-        accounts = accounts.filter((a) => !a.closed);
+      const milliunits = toMilliunits(params.amount);
+      const txId = crypto.randomUUID();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const lookups = buildLookups(budget.changed_entities ?? {});
+      const changedEntities = {};
+      let payeeId = params.payee_id ?? null;
+      if (!payeeId && params.payee_name) {
+        const resolved = resolvePayee(budget.changed_entities?.be_payees ?? [], params.payee_name);
+        payeeId = resolved.payeeId;
+        if (resolved.newPayee) {
+          changedEntities.be_payees = [resolved.newPayee];
+          lookups.payees.set(resolved.payeeId, params.payee_name);
+        }
+      }
+      changedEntities.be_transaction_groups = [
+        {
+          id: txId,
+          be_transaction: {
+            id: txId,
+            is_tombstone: false,
+            entities_account_id: params.account_id,
+            entities_payee_id: payeeId,
+            entities_subcategory_id: params.category_id ?? null,
+            entities_scheduled_transaction_id: null,
+            date: params.date,
+            date_entered_from_schedule: null,
+            amount: milliunits,
+            // cash_amount and credit_amount are server-computed splits the account
+            // type determines. Captured from a credit card account create where
+            // YNAB's UI sent zeros and the server populated them on response —
+            // not yet verified for cash/checking accounts but likely the same
+            // pattern.
+            cash_amount: 0,
+            credit_amount: 0,
+            credit_amount_adjusted: 0,
+            subcategory_credit_amount_preceding: 0,
+            memo: params.memo ?? null,
+            cleared: CLEARED_MAP[params.cleared ?? "uncleared"],
+            // YNAB's wire format calls this "accepted"; the public tool surface uses "approved".
+            accepted: params.approved ?? true,
+            check_number: null,
+            flag: params.flag_color ? FLAG_MAP[params.flag_color] : null,
+            transfer_account_id: null,
+            transfer_transaction_id: null,
+            transfer_subtransaction_id: null,
+            matched_transaction_id: null,
+            ynab_id: null,
+            // Import-related fields are only populated by bank-feed imports, not manual entry.
+            imported_payee: null,
+            imported_date: null,
+            original_imported_payee: null,
+            provider_cleansed_payee: null,
+            source: null,
+            debt_transaction_type: null
+          },
+          be_subtransactions: null
+        }
+      ];
+      const result = await syncWrite(planId, changedEntities, serverKnowledge);
+      const saved = result.changed_entities?.be_transactions?.find((t) => t.id === txId);
+      if (!saved) {
+        throw ToolError.internal("Transaction was created but no data was returned");
       }
-      return { accounts };
+      return { transaction: mapTransaction(saved, lookups) };
+    }
+  });
+
+  // src/tools/delete-category.ts
+  var deleteCategory = defineTool({
+    name: "delete_category",
+    displayName: "Delete Category",
+    description: "Delete a category from the active YNAB plan. This is a soft delete (tombstone). Existing transactions assigned to this category remain in place but the category will no longer appear in budget views.",
+    summary: "Delete a category",
+    icon: "trash-2",
+    group: "Categories",
+    input: external_exports.object({
+      category_id: external_exports.string().min(1).describe("Category ID to delete")
+    }),
+    output: external_exports.object({
+      success: external_exports.boolean()
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const existing2 = findCategory(budget.changed_entities, params.category_id);
+      assertCategoryDeletable(existing2);
+      await syncWrite(
+        planId,
+        { be_subcategories: [{ ...existing2, is_tombstone: true }] },
+        serverKnowledge
+      );
+      return { success: true };
+    }
+  });
+
+  // src/tools/delete-category-group.ts
+  var deleteCategoryGroup = defineTool({
+    name: "delete_category_group",
+    displayName: "Delete Category Group",
+    description: "Delete a category group and all of its child categories from the active YNAB plan. This is a soft delete (tombstone). Internal/non-deletable groups (Credit Card Payments, Hidden Categories, Internal Master Category) cannot be deleted.",
+    summary: "Delete a category group and its children",
+    icon: "folder-x",
+    group: "Categories",
+    input: external_exports.object({
+      group_id: external_exports.string().min(1).describe("Category group ID to delete")
+    }),
+    output: external_exports.object({
+      success: external_exports.boolean(),
+      deleted_category_count: external_exports.number().describe("Number of child categories that were also tombstoned")
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const group = findCategoryGroup(budget.changed_entities, params.group_id);
+      assertCategoryGroupDeletable(group);
+      const childCategories = (budget.changed_entities?.be_subcategories ?? []).filter(
+        (c) => c.entities_master_category_id === params.group_id && notTombstone(c)
+      );
+      await syncWrite(
+        planId,
+        {
+          be_master_categories: [{ ...group, is_tombstone: true }],
+          be_subcategories: childCategories.map((c) => ({ ...c, is_tombstone: true }))
+        },
+        serverKnowledge
+      );
+      return { success: true, deleted_category_count: childCategories.length };
+    }
+  });
+
+  // src/tools/delete-transaction.ts
+  var deleteTransaction = defineTool({
+    name: "delete_transaction",
+    displayName: "Delete Transaction",
+    description: "Delete a transaction from the active YNAB plan. This marks the transaction as deleted (soft delete). Transfer transactions cannot be deleted through this tool \u2014 delete them directly in YNAB.",
+    summary: "Delete a transaction",
+    icon: "trash-2",
+    group: "Transactions",
+    input: external_exports.object({
+      transaction_id: external_exports.string().min(1).describe("Transaction ID to delete"),
+      account_id: external_exports.string().min(1).describe("Account ID the transaction belongs to")
+    }),
+    output: external_exports.object({
+      success: external_exports.boolean().describe("Whether the operation succeeded")
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const existing2 = budget.changed_entities?.be_transactions?.find(
+        (t) => t.id === params.transaction_id && !t.is_tombstone
+      );
+      if (!existing2) {
+        throw ToolError.notFound(`Transaction not found: ${params.transaction_id}`);
+      }
+      if (existing2.transfer_account_id) {
+        throw ToolError.validation("Cannot delete transfer transactions \u2014 delete them in YNAB directly.");
+      }
+      await syncWrite(
+        planId,
+        {
+          be_transaction_groups: [
+            {
+              id: params.transaction_id,
+              be_transaction: {
+                ...existing2,
+                is_tombstone: true
+              },
+              be_subtransactions: null
+            }
+          ]
+        },
+        serverKnowledge
+      );
+      return { success: true };
     }
   });
 
@@ -14594,7 +15136,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const result = await syncBudget(planId);
       const entities = result.changed_entities;
       const raw = entities?.be_accounts ?? [];
-      const calcMap = new Map((entities?.be_account_calculations ?? []).map((c) => [c.entities_account_id, c]));
+      const calcMap = buildAccountCalcMap(entities ?? {});
       const account = raw.find((a) => a.id === params.account_id && !a.is_tombstone);
       if (!account) {
         throw ToolError.notFound(`Account not found: ${params.account_id}`);
@@ -14603,103 +15145,205 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
-  // src/tools/list-categories.ts
-  var listCategories = defineTool({
-    name: "list_categories",
-    displayName: "List Categories",
-    description: "List all category groups and categories in the active YNAB plan. Returns budgeted amounts, activity, and available balances for the current month. Excludes hidden and deleted categories by default.",
-    summary: "List budget categories with balances",
-    icon: "tags",
-    group: "Categories",
+  // src/tools/get-current-user.ts
+  var getCurrentUser = defineTool({
+    name: "get_current_user",
+    displayName: "Get Current User",
+    description: "Get the profile of the currently authenticated YNAB user including name and email.",
+    summary: "Get your YNAB user profile",
+    icon: "user",
+    group: "Account",
+    input: external_exports.object({}),
+    output: external_exports.object({ user: userSchema }),
+    handle: async () => {
+      const data = await api("/user");
+      return { user: mapUser(data) };
+    }
+  });
+
+  // src/tools/get-month.ts
+  var getMonth = defineTool({
+    name: "get_month",
+    displayName: "Get Month",
+    description: "Get budget summary and category details for a specific month. Returns the month overview (income, budgeted, activity, Ready to Assign) plus per-category breakdowns. Month format is YYYY-MM-DD using the first of the month (e.g. 2026-03-01).",
+    summary: "Get budget details for a month",
+    icon: "calendar",
+    group: "Months",
     input: external_exports.object({
+      month: external_exports.string().min(1).describe("Month in YYYY-MM-DD format (first of month, e.g. 2026-03-01)"),
       include_hidden: external_exports.boolean().optional().describe("Include hidden categories (default false)")
     }),
     output: external_exports.object({
-      groups: external_exports.array(categoryGroupSchema).describe("Category groups"),
-      categories: external_exports.array(categorySchema).describe("Categories with budget data")
+      month: monthSchema,
+      categories: external_exports.array(categorySchema).describe("Category budgets for this month")
     }),
     handle: async (params) => {
       const planId = getPlanId();
       const result = await syncBudget(planId);
       const entities = result.changed_entities;
-      const rawGroups = (entities?.be_master_categories ?? []).filter((g) => !g.is_tombstone);
-      const rawCategories = (entities?.be_subcategories ?? []).filter((c) => !c.is_tombstone);
-      const calcs = entities?.be_monthly_subcategory_budget_calculations ?? [];
-      const calcMap = /* @__PURE__ */ new Map();
-      for (const calc of calcs) {
-        const entityId = calc.entities_monthly_subcategory_budget_id;
-        if (entityId) {
-          const parts = entityId.split("/");
-          const categoryId = parts.length >= 3 ? parts.slice(2).join("/") : entityId;
-          calcMap.set(categoryId, calc);
-        }
+      const rawMonths = entities?.be_monthly_budgets ?? [];
+      const monthData = rawMonths.find((m) => m.month === params.month && !m.is_tombstone);
+      if (!monthData) {
+        throw ToolError.notFound(`Month not found: ${params.month}`);
       }
-      let groups = rawGroups.map(mapCategoryGroup);
-      let categories = rawCategories.map((c) => {
-        const calc = calcMap.get(c.id ?? "");
-        return mapCategory({
-          ...c,
-          budgeted: calc?.budgeted ?? c.budgeted,
-          activity: calc?.activity ?? c.activity,
-          balance: calc?.balance ?? c.balance,
-          goal_type: calc?.goal_type ?? c.goal_type,
-          goal_target: calc?.goal_target ?? c.goal_target,
-          goal_percentage_complete: calc?.goal_percentage_complete ?? c.goal_percentage_complete
-        });
+      const monthKey = toMonthKey(params.month);
+      const monthCalcMap = buildMonthlyBudgetCalcMap(entities?.be_monthly_budget_calculations ?? []);
+      const monthCalc = monthCalcMap.get(monthKey);
+      const rawCategories = (entities?.be_subcategories ?? []).filter(
+        (c) => notTombstone(c) && (params.include_hidden || c.is_hidden !== true)
+      );
+      const budgetMap = buildSubcategoryBudgetMap(entities?.be_monthly_subcategory_budgets ?? []);
+      const calcMap = buildSubcategoryCalcMap(entities?.be_monthly_subcategory_budget_calculations ?? []);
+      const categories = rawCategories.map((c) => mapCategoryForMonth(c, budgetMap, calcMap, monthKey));
+      return {
+        month: mapMonth(monthData, monthCalc),
+        categories
+      };
+    }
+  });
+
+  // src/tools/get-plan.ts
+  var getPlan = defineTool({
+    name: "get_plan",
+    displayName: "Get Plan",
+    description: "Get details about the currently active YNAB plan (budget), including name, currency, and date format. The plan ID is extracted from the current URL.",
+    summary: "Get the active plan details",
+    icon: "wallet",
+    group: "Plans",
+    input: external_exports.object({}),
+    output: external_exports.object({ plan: planSchema }),
+    handle: async () => {
+      assertAuthenticated();
+      const result = await catalog("getInitialUserData", {
+        device_info: { id: getDeviceId(), device_os: "web" }
       });
-      if (!params.include_hidden) {
-        groups = groups.filter((g) => !g.hidden);
-        categories = categories.filter((c) => !c.hidden);
+      const budgetVersion = result.budget_version;
+      if (!budgetVersion) {
+        throw ToolError.notFound("No active plan found");
       }
-      return { groups, categories };
+      return { plan: mapPlan(budgetVersion) };
     }
   });
 
-  // src/tools/update-category-budget.ts
-  var updateCategoryBudget = defineTool({
-    name: "update_category_budget",
-    displayName: "Update Category Budget",
-    description: "Set the budgeted amount for a category in a specific month. Amount is in currency units (e.g. 500 to budget $500). The month should be in YYYY-MM format (e.g. 2026-03 for March 2026).",
-    summary: "Set budgeted amount for a category",
-    icon: "pencil",
-    group: "Categories",
+  // src/tools/get-transaction.ts
+  var getTransaction = defineTool({
+    name: "get_transaction",
+    displayName: "Get Transaction",
+    description: "Get details for a specific transaction by its ID. Returns full transaction data including any split subtransactions.",
+    summary: "Get transaction details by ID",
+    icon: "receipt",
+    group: "Transactions",
     input: external_exports.object({
-      category_id: external_exports.string().min(1).describe("Category ID to budget"),
-      month: external_exports.string().min(1).describe("Month in YYYY-MM format (e.g. 2026-03)"),
-      budgeted: external_exports.number().describe("Amount to budget in currency units (e.g. 500 for $500)")
+      transaction_id: external_exports.string().min(1).describe("Transaction ID to retrieve")
     }),
     output: external_exports.object({
-      category: categorySchema
+      transaction: transactionSchema,
+      subtransactions: external_exports.array(subtransactionSchema).describe("Split subtransactions (empty if not a split)")
     }),
     handle: async (params) => {
       const planId = getPlanId();
-      const milliunits = Math.round(params.budgeted * 1e3);
-      const monthKey = params.month.substring(0, 7);
-      const budgetId = `mcb/${monthKey}/${params.category_id}`;
-      const monthlyBudgetId = `mb/${monthKey}/${planId}`;
-      const result = await syncWrite(planId, {
-        be_monthly_subcategory_budgets: [
-          {
-            id: budgetId,
-            entities_monthly_budget_id: monthlyBudgetId,
-            entities_subcategory_id: params.category_id,
-            budgeted: milliunits,
-            overspending_handling: "AffectsBuffer",
-            is_tombstone: false
-          }
-        ]
-      });
-      const budgets = result.changed_entities?.be_monthly_subcategory_budgets;
-      const updatedBudget = budgets?.[0]?.budgeted ?? milliunits;
+      const result = await syncBudget(planId);
+      const entities = result.changed_entities;
+      const raw = entities?.be_transactions ?? [];
+      const tx = raw.find((t) => t.id === params.transaction_id && !t.is_tombstone);
+      if (!tx) {
+        throw ToolError.notFound(`Transaction not found: ${params.transaction_id}`);
+      }
+      const lookups = buildLookups(entities ?? {});
+      const allSubs = entities?.be_subtransactions ?? [];
+      const subtransactions = allSubs.filter((s) => s.entities_transaction_id === params.transaction_id && !s.is_tombstone).map((s) => mapSubtransaction(s, lookups));
       return {
-        category: mapCategory({
-          id: params.category_id,
-          budgeted: updatedBudget
-        })
+        transaction: mapTransaction(tx, lookups),
+        subtransactions
       };
     }
   });
 
+  // src/tools/list-accounts.ts
+  var listAccounts = defineTool({
+    name: "list_accounts",
+    displayName: "List Accounts",
+    description: "List all accounts in the active YNAB plan. Returns account name, type, balances, and on-budget status. Includes checking, savings, credit cards, and tracking accounts.",
+    summary: "List all budget accounts",
+    icon: "landmark",
+    group: "Accounts",
+    input: external_exports.object({
+      include_closed: external_exports.boolean().optional().describe("Include closed accounts (default false)")
+    }),
+    output: external_exports.object({
+      accounts: external_exports.array(accountSchema).describe("List of accounts")
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const result = await syncBudget(planId);
+      const entities = result.changed_entities;
+      const raw = entities?.be_accounts ?? [];
+      const calcMap = buildAccountCalcMap(entities ?? {});
+      let accounts = raw.filter(notTombstone).map((a) => mapAccount(a, calcMap.get(a.id)));
+      if (!params.include_closed) {
+        accounts = accounts.filter((a) => !a.closed);
+      }
+      return { accounts };
+    }
+  });
+
+  // src/tools/list-categories.ts
+  var listCategories = defineTool({
+    name: "list_categories",
+    displayName: "List Categories",
+    description: "List category groups and categories in the active YNAB plan. Returns budgeted amounts, activity, and available balances for the current month. Hidden and deleted categories are excluded by default \u2014 pass include_hidden=true to also see hidden categories (useful for editing budgets on hidden categories).",
+    summary: "List budget categories with balances",
+    icon: "tags",
+    group: "Categories",
+    input: external_exports.object({
+      include_hidden: external_exports.boolean().optional().describe("Include hidden categories (default false)")
+    }),
+    output: external_exports.object({
+      groups: external_exports.array(categoryGroupSchema).describe("Category groups"),
+      categories: external_exports.array(categorySchema).describe("Categories with budget data")
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const result = await syncBudget(planId);
+      const entities = result.changed_entities;
+      const rawGroups = (entities?.be_master_categories ?? []).filter(notTombstone);
+      const rawCategories = (entities?.be_subcategories ?? []).filter(notTombstone);
+      const budgetMap = buildSubcategoryBudgetMap(entities?.be_monthly_subcategory_budgets ?? []);
+      const calcMap = buildSubcategoryCalcMap(entities?.be_monthly_subcategory_budget_calculations ?? []);
+      const currentMonth = currentMonthKey();
+      let groups = rawGroups.map(mapCategoryGroup);
+      let categories = rawCategories.map((c) => mapCategoryForMonth(c, budgetMap, calcMap, currentMonth));
+      if (!params.include_hidden) {
+        groups = groups.filter((g) => !g.hidden);
+        categories = categories.filter((c) => !c.hidden);
+      }
+      return { groups, categories };
+    }
+  });
+
+  // src/tools/list-months.ts
+  var listMonths = defineTool({
+    name: "list_months",
+    displayName: "List Months",
+    description: "List all budget months in the active YNAB plan. Returns income, budgeted, activity, and Ready to Assign amounts for each month. Sorted from most recent to oldest.",
+    summary: "List budget months with summaries",
+    icon: "calendar",
+    group: "Months",
+    input: external_exports.object({}),
+    output: external_exports.object({
+      months: external_exports.array(monthSchema).describe("List of budget months")
+    }),
+    handle: async () => {
+      const planId = getPlanId();
+      const result = await syncBudget(planId);
+      const entities = result.changed_entities;
+      const rawMonths = entities?.be_monthly_budgets ?? [];
+      const calcMap = buildMonthlyBudgetCalcMap(entities?.be_monthly_budget_calculations ?? []);
+      const months = rawMonths.filter(notTombstone).map((m) => mapMonth(m, calcMap.get((m.month ?? "").substring(0, 7)))).sort((a, b) => b.month.localeCompare(a.month));
+      return { months };
+    }
+  });
+
   // src/tools/list-payees.ts
   var listPayees = defineTool({
     name: "list_payees",
@@ -14716,11 +15360,34 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const planId = getPlanId();
       const result = await syncBudget(planId);
       const raw = result.changed_entities?.be_payees ?? [];
-      const payees = raw.filter((p) => !p.is_tombstone).map(mapPayee);
+      const payees = raw.filter(notTombstone).map(mapPayee);
       return { payees };
     }
   });
 
+  // src/tools/list-scheduled-transactions.ts
+  var listScheduledTransactions = defineTool({
+    name: "list_scheduled_transactions",
+    displayName: "List Scheduled Transactions",
+    description: "List all scheduled (recurring) transactions in the active YNAB plan. Returns frequency, next occurrence date, amount, payee, and category for each.",
+    summary: "List scheduled/recurring transactions",
+    icon: "clock",
+    group: "Transactions",
+    input: external_exports.object({}),
+    output: external_exports.object({
+      scheduled_transactions: external_exports.array(scheduledTransactionSchema).describe("List of scheduled transactions")
+    }),
+    handle: async () => {
+      const planId = getPlanId();
+      const result = await syncBudget(planId);
+      const entities = result.changed_entities;
+      const raw = entities?.be_scheduled_transactions ?? [];
+      const lookups = buildLookups(entities ?? {});
+      const scheduledTransactions = raw.filter(notTombstone).map((s) => mapScheduledTransaction(s, lookups)).sort((a, b) => a.date_next.localeCompare(b.date_next));
+      return { scheduled_transactions: scheduledTransactions };
+    }
+  });
+
   // src/tools/list-transactions.ts
   var listTransactions = defineTool({
     name: "list_transactions",
@@ -14731,7 +15398,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     group: "Transactions",
     input: external_exports.object({
       account_id: external_exports.string().optional().describe("Filter by account ID. Omit to list all transactions."),
-      since_date: external_exports.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD). Omit for all transactions.")
+      since_date: external_exports.string().optional().describe("Only return transactions on or after this date (YYYY-MM-DD). Omit for all transactions."),
+      until_date: external_exports.string().optional().describe(
+        "Only return transactions on or before this date (YYYY-MM-DD). Combine with since_date for a date range."
+      ),
+      payee_search: external_exports.string().optional().describe(
+        "Case-insensitive substring match against payee_name, imported_payee, and original_imported_payee. Useful for finding all transactions for a merchant without knowing the exact payee ID."
+      )
     }),
     output: external_exports.object({
       transactions: external_exports.array(transactionSchema).describe("List of transactions")
@@ -14739,112 +15412,292 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     handle: async (params) => {
       const planId = getPlanId();
       const result = await syncBudget(planId);
-      const raw = result.changed_entities?.be_transactions ?? [];
-      let transactions = raw.filter((t) => !t.is_tombstone).map(mapTransaction);
+      const entities = result.changed_entities;
+      const raw = entities?.be_transactions ?? [];
+      const lookups = buildLookups(entities ?? {});
+      let filtered = raw.filter(notTombstone);
       if (params.account_id) {
-        transactions = transactions.filter((t) => t.account_id === params.account_id);
+        filtered = filtered.filter((t) => t.entities_account_id === params.account_id);
       }
       if (params.since_date) {
         const sinceDate = params.since_date;
-        transactions = transactions.filter((t) => t.date >= sinceDate);
+        filtered = filtered.filter((t) => (t.date ?? "") >= sinceDate);
+      }
+      if (params.until_date) {
+        const untilDate = params.until_date;
+        filtered = filtered.filter((t) => (t.date ?? "") <= untilDate);
+      }
+      if (params.payee_search) {
+        const needle = params.payee_search.toLowerCase();
+        const matchingPayeeIds = /* @__PURE__ */ new Set();
+        for (const [id, name] of lookups.payees) {
+          if (name.toLowerCase().includes(needle)) matchingPayeeIds.add(id);
+        }
+        filtered = filtered.filter((t) => {
+          if (t.entities_payee_id && matchingPayeeIds.has(t.entities_payee_id)) return true;
+          if (t.imported_payee?.toLowerCase().includes(needle)) return true;
+          if (t.original_imported_payee?.toLowerCase().includes(needle)) return true;
+          return false;
+        });
       }
-      transactions.sort((a, b) => b.date.localeCompare(a.date));
+      const transactions = filtered.map((t) => mapTransaction(t, lookups)).sort((a, b) => b.date.localeCompare(a.date));
       return { transactions };
     }
   });
 
-  // src/tools/get-transaction.ts
-  var getTransaction = defineTool({
-    name: "get_transaction",
-    displayName: "Get Transaction",
-    description: "Get details for a specific transaction by its ID. Returns full transaction data including any split subtransactions.",
-    summary: "Get transaction details by ID",
-    icon: "receipt",
-    group: "Transactions",
+  // src/tools/move-category-budget.ts
+  var moveCategoryBudget = defineTool({
+    name: "move_category_budget",
+    displayName: "Move Category Budget",
+    description: "Move budgeted money between categories or to/from Ready to Assign for a specific month. Omit from_category_id to move money out of Ready to Assign; omit to_category_id to move money back to Ready to Assign. Both null is invalid.",
+    summary: "Move money between budget categories",
+    icon: "arrow-left-right",
+    group: "Categories",
     input: external_exports.object({
-      transaction_id: external_exports.string().min(1).describe("Transaction ID to retrieve")
+      month: external_exports.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, "Month must be YYYY-MM or YYYY-MM-DD").describe("Month in YYYY-MM format (e.g. 2026-03)"),
+      amount: external_exports.number().positive().describe("Amount to move in currency units (e.g. 50 for $50)"),
+      from_category_id: external_exports.string().optional().describe("Source category ID. Omit to move from Ready to Assign."),
+      to_category_id: external_exports.string().optional().describe("Destination category ID. Omit to move to Ready to Assign.")
+    }).refine((p) => p.from_category_id || p.to_category_id, {
+      message: "At least one of from_category_id or to_category_id must be provided"
+    }).refine((p) => !p.from_category_id || !p.to_category_id || p.from_category_id !== p.to_category_id, {
+      message: "from_category_id and to_category_id must differ"
     }),
     output: external_exports.object({
-      transaction: transactionSchema,
-      subtransactions: external_exports.array(subtransactionSchema).describe("Split subtransactions (empty if not a split)")
+      categories: external_exports.array(categorySchema).describe("Updated categories (1 if RTA is involved, 2 for category-to-category)")
     }),
     handle: async (params) => {
       const planId = getPlanId();
-      const result = await syncBudget(planId);
-      const entities = result.changed_entities;
-      const raw = entities?.be_transactions ?? [];
-      const tx = raw.find((t) => t.id === params.transaction_id && !t.is_tombstone);
-      if (!tx) {
-        throw ToolError.notFound(`Transaction not found: ${params.transaction_id}`);
+      const userId = getUserId();
+      const milliunits = toMilliunits(params.amount);
+      const monthKey = toMonthKey(params.month);
+      const monthlyBudgetId = formatMonthlyBudgetId(monthKey, planId);
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const existingBudgets = budget.changed_entities?.be_monthly_subcategory_budgets ?? [];
+      const fromCategoryId = params.from_category_id;
+      const toCategoryId = params.to_category_id;
+      const fromCategory = fromCategoryId ? findCategory(budget.changed_entities, fromCategoryId) : null;
+      const toCategory = toCategoryId ? findCategory(budget.changed_entities, toCategoryId) : null;
+      const fromBudgetId = fromCategoryId ? formatSubcategoryBudgetId(monthKey, fromCategoryId) : null;
+      const toBudgetId = toCategoryId ? formatSubcategoryBudgetId(monthKey, toCategoryId) : null;
+      const buildEntry = (categoryId, budgetId, signedDelta) => {
+        const current = existingBudgets.find((b) => b.id === budgetId && notTombstone(b))?.budgeted ?? 0;
+        return {
+          id: budgetId,
+          is_tombstone: false,
+          entities_monthly_budget_id: monthlyBudgetId,
+          entities_subcategory_id: categoryId,
+          budgeted: current + signedDelta
+        };
+      };
+      const budgetEntries = [];
+      if (fromCategoryId && fromBudgetId) budgetEntries.push(buildEntry(fromCategoryId, fromBudgetId, -milliunits));
+      if (toCategoryId && toBudgetId) budgetEntries.push(buildEntry(toCategoryId, toBudgetId, milliunits));
+      const source = fromCategoryId && toCategoryId ? MONEY_MOVEMENT_SOURCE.MOVEMENT : MONEY_MOVEMENT_SOURCE.ASSIGN;
+      const result = await syncWrite(
+        planId,
+        {
+          be_monthly_subcategory_budgets: budgetEntries,
+          be_money_movements: [
+            {
+              id: crypto.randomUUID(),
+              is_tombstone: false,
+              from_entities_monthly_subcategory_budget_id: fromBudgetId,
+              to_entities_monthly_subcategory_budget_id: toBudgetId,
+              entities_money_movement_group_id: null,
+              amount: milliunits,
+              performed_by_user_id: userId,
+              note: null,
+              source,
+              move_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+              move_accepted_at: null
+            }
+          ]
+        },
+        serverKnowledge
+      );
+      const calcMap = buildSubcategoryCalcMap(result.changed_entities?.be_monthly_subcategory_budget_calculations ?? []);
+      const budgetMap = buildSubcategoryBudgetMap(result.changed_entities?.be_monthly_subcategory_budgets ?? []);
+      for (const e of budgetEntries) {
+        const key = `${monthKey}/${e.entities_subcategory_id}`;
+        if (!budgetMap.has(key)) budgetMap.set(key, e);
       }
-      const allSubs = entities?.be_subtransactions ?? [];
-      const subtransactions = allSubs.filter((s) => s.entities_transaction_id === params.transaction_id && !s.is_tombstone).map(mapSubtransaction);
-      return {
-        transaction: mapTransaction(tx),
-        subtransactions
+      const categories = [];
+      if (fromCategory) categories.push(mapCategoryForMonth(fromCategory, budgetMap, calcMap, monthKey));
+      if (toCategory) categories.push(mapCategoryForMonth(toCategory, budgetMap, calcMap, monthKey));
+      return { categories };
+    }
+  });
+
+  // src/tools/snooze-category-goal.ts
+  var snoozeCategoryGoal = defineTool({
+    name: "snooze_category_goal",
+    displayName: "Snooze Category Goal",
+    description: "Snooze a category goal for a specific month so it does not appear as needing funding for that month. Pass snooze=false to un-snooze.",
+    summary: "Snooze a category goal for a month",
+    icon: "bell-off",
+    group: "Categories",
+    input: external_exports.object({
+      category_id: external_exports.string().min(1).describe("Category ID whose goal to snooze"),
+      month: external_exports.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, "Month must be YYYY-MM or YYYY-MM-DD").describe("Month in YYYY-MM format (e.g. 2026-04)"),
+      snooze: external_exports.boolean().optional().describe("true to snooze (default), false to un-snooze")
+    }),
+    output: external_exports.object({
+      success: external_exports.boolean(),
+      snoozed_at: external_exports.string().nullable().describe("ISO timestamp the goal was snoozed at, or null if un-snoozed")
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const monthKey = toMonthKey(params.month);
+      const budgetId = formatSubcategoryBudgetId(monthKey, params.category_id);
+      const monthlyBudgetId = formatMonthlyBudgetId(monthKey, planId);
+      const shouldSnooze = params.snooze ?? true;
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const category = findCategory(budget.changed_entities, params.category_id);
+      if (!category.goal_type) {
+        throw ToolError.validation(`Category "${category.name}" has no goal to snooze.`);
+      }
+      const existing2 = (budget.changed_entities?.be_monthly_subcategory_budgets ?? []).find(
+        (b) => b.id === budgetId && notTombstone(b)
+      );
+      const snoozedAt = shouldSnooze ? (/* @__PURE__ */ new Date()).toISOString() : null;
+      const budgetEntry = {
+        ...existing2 ?? {},
+        id: budgetId,
+        is_tombstone: false,
+        entities_monthly_budget_id: monthlyBudgetId,
+        entities_subcategory_id: params.category_id,
+        budgeted: existing2?.budgeted ?? 0,
+        goal_snoozed_at: snoozedAt
       };
+      await syncWrite(planId, { be_monthly_subcategory_budgets: [budgetEntry] }, serverKnowledge);
+      return { success: true, snoozed_at: snoozedAt };
     }
   });
 
-  // src/tools/create-transaction.ts
-  var createTransaction = defineTool({
-    name: "create_transaction",
-    displayName: "Create Transaction",
-    description: "Create a new transaction in the active YNAB plan. Amount is in currency units (e.g. -42.50 for a $42.50 expense, 1500 for $1500 income). Negative amounts are outflows (expenses), positive amounts are inflows (income).",
-    summary: "Create a new transaction",
-    icon: "plus",
-    group: "Transactions",
+  // src/tools/update-category.ts
+  var updateCategory = defineTool({
+    name: "update_category",
+    displayName: "Update Category",
+    description: 'Rename a category, change its group, set/clear its goal, or hide/unhide it. Only specified fields change; omitted fields remain unchanged. Goal types: "set_aside" / "refill" (recurring NEED with optional cadence), "target_balance" (have $X), "target_by_date" (have $X by date), "debt" (recurring debt payment), or "none" to clear an existing goal.',
+    summary: "Update a category",
+    icon: "pencil",
+    group: "Categories",
     input: external_exports.object({
-      account_id: external_exports.string().min(1).describe("Account ID to create the transaction in"),
-      date: external_exports.string().min(1).describe("Transaction date in YYYY-MM-DD format"),
-      amount: external_exports.number().describe(
-        "Amount in currency units (negative for expenses, positive for income). E.g. -42.50 for a $42.50 expense."
-      ),
-      payee_name: external_exports.string().optional().describe("Payee name (creates new payee if not found)"),
-      payee_id: external_exports.string().optional().describe("Existing payee ID (takes precedence over payee_name)"),
-      category_id: external_exports.string().optional().describe("Category ID to assign"),
-      memo: external_exports.string().optional().describe("Transaction memo"),
-      cleared: external_exports.enum(["cleared", "uncleared", "reconciled"]).optional().describe("Cleared status (default uncleared)"),
-      approved: external_exports.boolean().optional().describe("Whether the transaction is approved (default true)"),
-      flag_color: external_exports.enum(["red", "orange", "yellow", "green", "blue", "purple"]).optional().describe("Flag color")
+      category_id: external_exports.string().min(1).describe("Category ID to update"),
+      name: external_exports.string().min(1).optional().describe("New name"),
+      group_id: external_exports.string().min(1).optional().describe("New parent category group ID (to move the category)"),
+      goal: goalSpecSchema.optional().describe('New goal definition. Pass { type: "none" } to clear the goal.'),
+      hidden: external_exports.boolean().optional().describe("Hide or unhide the category"),
+      note: external_exports.string().optional().describe("New note (pass empty string to clear)")
     }),
     output: external_exports.object({
-      transaction: transactionSchema
+      category: categorySchema
     }),
     handle: async (params) => {
       const planId = getPlanId();
-      const milliunits = Math.round(params.amount * 1e3);
-      const txId = crypto.randomUUID();
-      const transaction = {
-        id: txId,
-        entities_account_id: params.account_id,
-        date: params.date,
-        amount: milliunits,
-        cleared: params.cleared ?? "uncleared",
-        approved: params.approved ?? true,
-        memo: params.memo ?? null,
-        flag_color: params.flag_color ?? null,
-        entities_payee_id: params.payee_id ?? null,
-        payee_name: params.payee_name ?? null,
-        entities_subcategory_id: params.category_id ?? null,
-        is_tombstone: false
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const existing2 = findCategory(budget.changed_entities, params.category_id);
+      if (params.group_id) {
+        assertCategoryGroupDeletable(findCategoryGroup(budget.changed_entities, params.group_id));
+      }
+      if (params.goal?.type === "debt" && existing2.entities_account_id == null) {
+        throw ToolError.validation("Debt goals can only be set on debt-account categories.");
+      }
+      const updated = {
+        ...existing2,
+        name: params.name ?? existing2.name,
+        entities_master_category_id: params.group_id ?? existing2.entities_master_category_id,
+        is_hidden: params.hidden ?? existing2.is_hidden,
+        note: params.note ?? existing2.note,
+        ...params.goal !== void 0 ? buildGoalFields(params.goal) : {}
       };
-      const result = await syncWrite(planId, {
-        be_transactions: [transaction]
-      });
-      const saved = result.changed_entities?.be_transactions?.[0];
-      if (!saved) {
-        throw ToolError.internal("Transaction was created but no data was returned");
+      await syncWrite(planId, { be_subcategories: [updated] }, serverKnowledge);
+      return { category: mapCategory(updated) };
+    }
+  });
+
+  // src/tools/update-category-budget.ts
+  var updateCategoryBudget = defineTool({
+    name: "update_category_budget",
+    displayName: "Update Category Budget",
+    description: "Set the budgeted amount for a category in a specific month. Amount is in currency units (e.g. 500 to budget $500). The month should be in YYYY-MM format (e.g. 2026-03 for March 2026).",
+    summary: "Set budgeted amount for a category",
+    icon: "pencil",
+    group: "Categories",
+    input: external_exports.object({
+      category_id: external_exports.string().min(1).describe("Category ID to budget"),
+      month: external_exports.string().regex(/^\d{4}-\d{2}(-\d{2})?$/, "Month must be YYYY-MM or YYYY-MM-DD").describe("Month in YYYY-MM format (e.g. 2026-03)"),
+      budgeted: external_exports.number().describe("Amount to budget in currency units (e.g. 500 for $500)")
+    }),
+    output: external_exports.object({
+      category: categorySchema
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      const userId = getUserId();
+      const milliunits = toMilliunits(params.budgeted);
+      const monthKey = toMonthKey(params.month);
+      const budgetId = formatSubcategoryBudgetId(monthKey, params.category_id);
+      const monthlyBudgetId = formatMonthlyBudgetId(monthKey, planId);
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const category = findCategory(budget.changed_entities, params.category_id);
+      const existingBudget = (budget.changed_entities?.be_monthly_subcategory_budgets ?? []).find(
+        (b) => b.id === budgetId && notTombstone(b)
+      );
+      const delta = milliunits - (existingBudget?.budgeted ?? 0);
+      const budgetEntry = {
+        id: budgetId,
+        is_tombstone: false,
+        entities_monthly_budget_id: monthlyBudgetId,
+        entities_subcategory_id: params.category_id,
+        budgeted: milliunits
+      };
+      const changedEntities = { be_monthly_subcategory_budgets: [budgetEntry] };
+      if (delta !== 0) {
+        changedEntities.be_money_movements = [
+          {
+            id: crypto.randomUUID(),
+            is_tombstone: false,
+            to_entities_monthly_subcategory_budget_id: delta > 0 ? budgetId : null,
+            from_entities_monthly_subcategory_budget_id: delta < 0 ? budgetId : null,
+            entities_money_movement_group_id: null,
+            amount: Math.abs(delta),
+            performed_by_user_id: userId,
+            note: null,
+            source: MONEY_MOVEMENT_SOURCE.ASSIGN,
+            move_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+            move_accepted_at: null
+          }
+        ];
       }
-      return { transaction: mapTransaction(saved) };
+      const result = await syncWrite(planId, changedEntities, serverKnowledge);
+      const calcMap = buildSubcategoryCalcMap(result.changed_entities?.be_monthly_subcategory_budget_calculations ?? []);
+      const budgetMap = buildSubcategoryBudgetMap(result.changed_entities?.be_monthly_subcategory_budgets ?? []);
+      const key = `${monthKey}/${params.category_id}`;
+      if (!budgetMap.has(key)) budgetMap.set(key, budgetEntry);
+      return { category: mapCategoryForMonth(category, budgetMap, calcMap, monthKey) };
     }
   });
 
   // src/tools/update-transaction.ts
+  var resolveFlag = (requested, existing2) => {
+    if (requested === "none") return null;
+    if (requested) return FLAG_MAP[requested];
+    return existing2 ?? null;
+  };
+  var resolveCleared = (requested, existing2) => {
+    if (requested) return CLEARED_MAP[requested];
+    return existing2 ?? "Uncleared";
+  };
   var updateTransaction = defineTool({
     name: "update_transaction",
     displayName: "Update Transaction",
-    description: "Update an existing transaction in the active YNAB plan. Only specified fields are changed; omitted fields remain unchanged. Amount is in currency units (negative for expenses, positive for income).",
+    description: "Update an existing transaction in the active YNAB plan. Only specified fields are changed; omitted fields remain unchanged. Amount is in currency units (negative for expenses, positive for income). Transfers and split transactions cannot be updated through this tool \u2014 edit them directly in YNAB.",
     summary: "Update a transaction",
     icon: "pencil",
     group: "Transactions",
@@ -14859,175 +15712,85 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       memo: external_exports.string().optional().describe("New transaction memo"),
       cleared: external_exports.enum(["cleared", "uncleared", "reconciled"]).optional().describe("New cleared status"),
       approved: external_exports.boolean().optional().describe("New approval status"),
-      flag_color: external_exports.enum(["red", "orange", "yellow", "green", "blue", "purple"]).optional().describe("New flag color")
+      flag_color: external_exports.enum(["red", "orange", "yellow", "green", "blue", "purple", "none"]).optional().describe('New flag color (pass "none" to clear)')
     }),
     output: external_exports.object({
       transaction: transactionSchema
     }),
     handle: async (params) => {
       const planId = getPlanId();
-      const transaction = {
-        id: params.transaction_id,
-        entities_account_id: params.account_id
-      };
-      if (params.date !== void 0) transaction.date = params.date;
-      if (params.amount !== void 0) transaction.amount = Math.round(params.amount * 1e3);
-      if (params.payee_name !== void 0) transaction.payee_name = params.payee_name;
-      if (params.payee_id !== void 0) transaction.entities_payee_id = params.payee_id;
-      if (params.category_id !== void 0) transaction.entities_subcategory_id = params.category_id;
-      if (params.memo !== void 0) transaction.memo = params.memo;
-      if (params.cleared !== void 0) transaction.cleared = params.cleared;
-      if (params.approved !== void 0) transaction.approved = params.approved;
-      if (params.flag_color !== void 0) transaction.flag_color = params.flag_color;
-      const result = await syncWrite(planId, {
-        be_transactions: [transaction]
-      });
-      const saved = result.changed_entities?.be_transactions?.[0];
-      if (!saved) {
-        throw ToolError.internal("Transaction was updated but no data was returned");
+      const budget = await syncBudget(planId);
+      const serverKnowledge = budget.current_server_knowledge ?? 0;
+      const lookups = buildLookups(budget.changed_entities ?? {});
+      const existing2 = budget.changed_entities?.be_transactions?.find(
+        (t) => t.id === params.transaction_id && !t.is_tombstone
+      );
+      if (!existing2) {
+        throw ToolError.notFound(`Transaction not found: ${params.transaction_id}`);
       }
-      return { transaction: mapTransaction(saved) };
-    }
-  });
-
-  // src/tools/delete-transaction.ts
-  var deleteTransaction = defineTool({
-    name: "delete_transaction",
-    displayName: "Delete Transaction",
-    description: "Delete a transaction from the active YNAB plan. This marks the transaction as deleted (soft delete).",
-    summary: "Delete a transaction",
-    icon: "trash-2",
-    group: "Transactions",
-    input: external_exports.object({
-      transaction_id: external_exports.string().min(1).describe("Transaction ID to delete"),
-      account_id: external_exports.string().min(1).describe("Account ID the transaction belongs to")
-    }),
-    output: external_exports.object({
-      success: external_exports.boolean().describe("Whether the operation succeeded")
-    }),
-    handle: async (params) => {
-      const planId = getPlanId();
-      await syncWrite(planId, {
-        be_transactions: [
-          {
+      if (existing2.transfer_account_id) {
+        throw ToolError.validation("Cannot update transfer transactions \u2014 edit them in YNAB directly.");
+      }
+      const hasSubtransactions = (budget.changed_entities?.be_subtransactions ?? []).some(
+        (s) => s.entities_transaction_id === params.transaction_id && !s.is_tombstone
+      );
+      if (hasSubtransactions) {
+        throw ToolError.validation("Cannot update split transactions \u2014 edit them in YNAB directly.");
+      }
+      const changedEntities = {};
+      let payeeId = params.payee_id ?? existing2.entities_payee_id ?? null;
+      if (params.payee_name && !params.payee_id) {
+        const resolved = resolvePayee(budget.changed_entities?.be_payees ?? [], params.payee_name);
+        payeeId = resolved.payeeId;
+        if (resolved.newPayee) {
+          changedEntities.be_payees = [resolved.newPayee];
+          lookups.payees.set(resolved.payeeId, params.payee_name);
+        }
+      }
+      changedEntities.be_transaction_groups = [
+        {
+          id: params.transaction_id,
+          be_transaction: {
             id: params.transaction_id,
+            is_tombstone: false,
             entities_account_id: params.account_id,
-            is_tombstone: true
-          }
-        ]
-      });
-      return { success: true };
-    }
-  });
-
-  // src/tools/list-scheduled-transactions.ts
-  var listScheduledTransactions = defineTool({
-    name: "list_scheduled_transactions",
-    displayName: "List Scheduled Transactions",
-    description: "List all scheduled (recurring) transactions in the active YNAB plan. Returns frequency, next occurrence date, amount, payee, and category for each.",
-    summary: "List scheduled/recurring transactions",
-    icon: "clock",
-    group: "Transactions",
-    input: external_exports.object({}),
-    output: external_exports.object({
-      scheduled_transactions: external_exports.array(scheduledTransactionSchema).describe("List of scheduled transactions")
-    }),
-    handle: async () => {
-      const planId = getPlanId();
-      const result = await syncBudget(planId);
-      const raw = result.changed_entities?.be_scheduled_transactions ?? [];
-      const scheduledTransactions = raw.filter((s) => !s.is_tombstone).map(mapScheduledTransaction).sort((a, b) => a.date_next.localeCompare(b.date_next));
-      return { scheduled_transactions: scheduledTransactions };
-    }
-  });
-
-  // src/tools/list-months.ts
-  var listMonths = defineTool({
-    name: "list_months",
-    displayName: "List Months",
-    description: "List all budget months in the active YNAB plan. Returns income, budgeted, activity, and Ready to Assign amounts for each month. Sorted from most recent to oldest.",
-    summary: "List budget months with summaries",
-    icon: "calendar",
-    group: "Months",
-    input: external_exports.object({}),
-    output: external_exports.object({
-      months: external_exports.array(monthSchema).describe("List of budget months")
-    }),
-    handle: async () => {
-      const planId = getPlanId();
-      const result = await syncBudget(planId);
-      const entities = result.changed_entities;
-      const rawMonths = entities?.be_monthly_budgets ?? [];
-      const rawCalcs = entities?.be_monthly_budget_calculations ?? [];
-      const calcMap = /* @__PURE__ */ new Map();
-      for (const calc of rawCalcs) {
-        const budgetId = calc.entities_monthly_budget_id;
-        if (budgetId) {
-          const month = budgetId.replace("mb/", "");
-          calcMap.set(month, calc);
+            entities_payee_id: payeeId,
+            entities_subcategory_id: params.category_id ?? existing2.entities_subcategory_id ?? null,
+            entities_scheduled_transaction_id: existing2.entities_scheduled_transaction_id ?? null,
+            date: params.date ?? existing2.date ?? "",
+            date_entered_from_schedule: null,
+            amount: params.amount !== void 0 ? toMilliunits(params.amount) : existing2.amount ?? 0,
+            cash_amount: 0,
+            credit_amount: 0,
+            credit_amount_adjusted: 0,
+            subcategory_credit_amount_preceding: 0,
+            memo: params.memo ?? existing2.memo ?? null,
+            cleared: resolveCleared(params.cleared, existing2.cleared),
+            // YNAB's wire format calls this "accepted"; the public tool surface uses "approved".
+            accepted: params.approved ?? existing2.accepted ?? false,
+            check_number: null,
+            flag: resolveFlag(params.flag_color, existing2.flag),
+            transfer_account_id: existing2.transfer_account_id ?? null,
+            transfer_transaction_id: null,
+            transfer_subtransaction_id: null,
+            matched_transaction_id: null,
+            ynab_id: existing2.ynab_id ?? null,
+            imported_payee: existing2.imported_payee ?? null,
+            imported_date: null,
+            original_imported_payee: existing2.original_imported_payee ?? null,
+            provider_cleansed_payee: null,
+            source: existing2.source ?? null,
+            debt_transaction_type: null
+          },
+          be_subtransactions: null
         }
+      ];
+      const result = await syncWrite(planId, changedEntities, serverKnowledge);
+      const saved = result.changed_entities?.be_transactions?.find((t) => t.id === params.transaction_id);
+      if (!saved) {
+        throw ToolError.internal("Transaction was updated but no data was returned");
       }
-      const months = rawMonths.filter((m) => !m.is_tombstone).map((m) => mapMonth(m, calcMap.get(m.month ?? ""))).sort((a, b) => b.month.localeCompare(a.month));
-      return { months };
-    }
-  });
-
-  // src/tools/get-month.ts
-  var getMonth = defineTool({
-    name: "get_month",
-    displayName: "Get Month",
-    description: "Get budget summary and category details for a specific month. Returns the month overview (income, budgeted, activity, Ready to Assign) plus per-category breakdowns. Month format is YYYY-MM-DD using the first of the month (e.g. 2026-03-01).",
-    summary: "Get budget details for a month",
-    icon: "calendar",
-    group: "Months",
-    input: external_exports.object({
-      month: external_exports.string().min(1).describe("Month in YYYY-MM-DD format (first of month, e.g. 2026-03-01)")
-    }),
-    output: external_exports.object({
-      month: monthSchema,
-      categories: external_exports.array(categorySchema).describe("Category budgets for this month")
-    }),
-    handle: async (params) => {
-      const planId = getPlanId();
-      const result = await syncBudget(planId);
-      const entities = result.changed_entities;
-      const rawMonths = entities?.be_monthly_budgets ?? [];
-      const monthData = rawMonths.find((m) => m.month === params.month && !m.is_tombstone);
-      if (!monthData) {
-        throw ToolError.notFound(`Month not found: ${params.month}`);
-      }
-      const monthlyCalcs = entities?.be_monthly_budget_calculations ?? [];
-      const monthCalc = monthlyCalcs.find((c) => {
-        const budgetId = c.entities_monthly_budget_id;
-        return budgetId && budgetId.replace("mb/", "") === params.month;
-      });
-      const rawCategories = (entities?.be_subcategories ?? []).filter((c) => !c.is_tombstone && c.is_hidden !== true);
-      const subcatCalcs = entities?.be_monthly_subcategory_budget_calculations ?? [];
-      const calcMap = /* @__PURE__ */ new Map();
-      for (const calc of subcatCalcs) {
-        const entityId = calc.entities_monthly_subcategory_budget_id;
-        if (entityId) {
-          const parts = entityId.split("/");
-          const categoryId = parts.length >= 3 ? parts.slice(2).join("/") : entityId;
-          calcMap.set(categoryId, calc);
-        }
-      }
-      const categories = rawCategories.map((c) => {
-        const calc = calcMap.get(c.id ?? "");
-        return mapCategory({
-          ...c,
-          budgeted: calc?.budgeted ?? c.budgeted,
-          activity: calc?.activity ?? c.activity,
-          balance: calc?.balance ?? c.balance,
-          goal_type: calc?.goal_type ?? c.goal_type,
-          goal_target: calc?.goal_target ?? c.goal_target,
-          goal_percentage_complete: calc?.goal_percentage_complete ?? c.goal_percentage_complete
-        });
-      });
-      return {
-        month: mapMonth(monthData, monthCalc),
-        categories
-      };
+      return { transaction: mapTransaction(saved, lookups) };
     }
   });
 
@@ -15048,7 +15811,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       getAccount,
       // Categories
       listCategories,
+      createCategory,
+      updateCategory,
+      deleteCategory,
+      createCategoryGroup,
+      deleteCategoryGroup,
       updateCategoryBudget,
+      moveCategoryBudget,
+      snoozeCategoryGoal,
       // Payees
       listPayees,
       // Transactions
@@ -15069,7 +15839,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   };
   var src_default = new YnabPlugin();
 
-  // dist/_adapter_entry_331af839-0591-41a5-afc4-b832c8b79610.ts
+  // dist/_adapter_entry_0fc84288-9dca-44bb-92da-639aeea53a88.ts
   if (!globalThis.__openTabs) {
     globalThis.__openTabs = {};
   } else {
@@ -15285,5 +16055,5 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     };
     delete src_default.onDeactivate;
   }
-})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["ynab"]){var a=o.adapters["ynab"];a.__adapterHash="0559e5ad8503b3f1094920c7c7fb557b8f9e39f79aa5dd2919a91ca6b0f29c1e";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"ynab",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
+})();(function(){var o=(globalThis).__openTabs;if(o&&o.adapters&&o.adapters["ynab"]){var a=o.adapters["ynab"];a.__adapterHash="3a2d11d4883f6b89713b9ed3995d0c919e24e6ae5699ae84dc071e130223def6";if(a.tools&&Array.isArray(a.tools)){for(var i=0;i<a.tools.length;i++){Object.freeze(a.tools[i]);}Object.freeze(a.tools);}Object.freeze(a);Object.defineProperty(o.adapters,"ynab",{value:a,writable:false,configurable:false,enumerable:true});Object.defineProperty(o,"adapters",{value:o.adapters,writable:false,configurable:false});}})();
 //# sourceMappingURL=adapter.iife.js.map