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

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,187 @@ 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 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 +14329,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 +14336,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 +14363,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 +14384,119 @@ 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 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 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 ?? []).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_target: calc?.goal_target ?? c.goal_target,
+      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 +14511,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 +14520,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 ?? "",
@@ -14443,36 +14569,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,27 +14617,198 @@ 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/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({
+      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({
+      transaction: transactionSchema
+    }),
+    handle: async (params) => {
+      const planId = getPlanId();
+      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 { transaction: mapTransaction(saved, lookups) };
+    }
+  });
+
+  // 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 };
+    }
+  });
+
+  // src/tools/get-account.ts
+  var getAccount = defineTool({
+    name: "get_account",
+    displayName: "Get Account",
+    description: "Get details for a specific account in the active YNAB plan by its ID. Returns name, type, balances, and on-budget status.",
+    summary: "Get account details by ID",
+    icon: "landmark",
+    group: "Accounts",
+    input: external_exports.object({
+      account_id: external_exports.string().min(1).describe("Account ID to retrieve")
+    }),
+    output: external_exports.object({
+      account: accountSchema
+    }),
+    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 ?? {});
+      const account = raw.find((a) => a.id === params.account_id && !a.is_tombstone);
+      if (!account) {
+        throw ToolError.notFound(`Account not found: ${params.account_id}`);
+      }
+      return { account: mapAccount(account, calcMap.get(account.id)) };
+    }
+  });
+
   // src/tools/get-current-user.ts
   var getCurrentUser = defineTool({
     name: "get_current_user",
@@ -14528,6 +14825,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
+  // 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({
+      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 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",
@@ -14539,67 +14877,77 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     input: external_exports.object({}),
     output: external_exports.object({ plan: planSchema }),
     handle: async () => {
-      const planId = getPlanId();
+      assertAuthenticated();
       const result = await catalog("getInitialUserData", {
-        device_info: { id: planId, device_os: "web" }
+        device_info: { id: getDeviceId(), device_os: "web" }
       });
-      return { plan: mapPlan(result.budget_version) };
+      const budgetVersion = result.budget_version;
+      if (!budgetVersion) {
+        throw ToolError.notFound("No active plan found");
+      }
+      return { plan: mapPlan(budgetVersion) };
     }
   });
 
-  // 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/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({
-      include_closed: external_exports.boolean().optional().describe("Include closed accounts (default false)")
+      transaction_id: external_exports.string().min(1).describe("Transaction ID to retrieve")
     }),
     output: external_exports.object({
-      accounts: external_exports.array(accountSchema).describe("List of accounts")
+      transaction: transactionSchema,
+      subtransactions: external_exports.array(subtransactionSchema).describe("Split subtransactions (empty if not a split)")
     }),
     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 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}`);
       }
-      return { accounts };
+      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 {
+        transaction: mapTransaction(tx, lookups),
+        subtransactions
+      };
     }
   });
 
-  // src/tools/get-account.ts
-  var getAccount = defineTool({
-    name: "get_account",
-    displayName: "Get Account",
-    description: "Get details for a specific account in the active YNAB plan by its ID. Returns name, type, balances, and on-budget status.",
-    summary: "Get account details by ID",
+  // 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({
-      account_id: external_exports.string().min(1).describe("Account ID to retrieve")
+      include_closed: external_exports.boolean().optional().describe("Include closed accounts (default false)")
     }),
     output: external_exports.object({
-      account: accountSchema
+      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 = new Map((entities?.be_account_calculations ?? []).map((c) => [c.entities_account_id, c]));
-      const account = raw.find((a) => a.id === params.account_id && !a.is_tombstone);
-      if (!account) {
-        throw ToolError.notFound(`Account not found: ${params.account_id}`);
+      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 { account: mapAccount(account, calcMap.get(account.id)) };
+      return { accounts };
     }
   });
 
@@ -14607,7 +14955,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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.",
+    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",
@@ -14622,31 +14970,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       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 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) => {
-        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
-        });
-      });
+      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);
@@ -14655,48 +14985,26 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   });
 
-  // 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().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)")
-    }),
+  // 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({
-      category: categorySchema
+      months: external_exports.array(monthSchema).describe("List of budget months")
     }),
-    handle: async (params) => {
+    handle: async () => {
       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;
-      return {
-        category: mapCategory({
-          id: params.category_id,
-          budgeted: updatedBudget
-        })
-      };
+      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 };
     }
   });
 
@@ -14716,11 +15024,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 +15062,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 +15076,211 @@ 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 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 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 subcategories = budget.changed_entities?.be_subcategories ?? [];
+      const existingBudgets = budget.changed_entities?.be_monthly_subcategory_budgets ?? [];
+      const findCategory = (id) => {
+        const c = subcategories.find((s) => s.id === id && notTombstone(s));
+        if (!c?.id) throw ToolError.notFound(`Category not found: ${id}`);
+        return { ...c, id: c.id };
+      };
+      const fromCategory = params.from_category_id ? findCategory(params.from_category_id) : null;
+      const toCategory = params.to_category_id ? findCategory(params.to_category_id) : null;
+      const fromBudgetId = fromCategory ? formatSubcategoryBudgetId(monthKey, fromCategory.id) : null;
+      const toBudgetId = toCategory ? formatSubcategoryBudgetId(monthKey, toCategory.id) : 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 (fromCategory && fromBudgetId) budgetEntries.push(buildEntry(fromCategory.id, fromBudgetId, -milliunits));
+      if (toCategory && toBudgetId) budgetEntries.push(buildEntry(toCategory.id, toBudgetId, milliunits));
+      const source = fromCategory && toCategory ? 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 categories = [];
+      if (fromCategory) categories.push(mapCategoryForMonth(fromCategory, budgetMap, calcMap, monthKey));
+      if (toCategory) categories.push(mapCategoryForMonth(toCategory, budgetMap, calcMap, monthKey));
+      return { categories };
     }
   });
 
-  // 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-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({
-      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 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({
-      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 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 = (budget.changed_entities?.be_subcategories ?? []).find(
+        (c) => c.id === params.category_id && notTombstone(c)
+      );
+      if (!category) {
+        throw ToolError.notFound(`Category not found: ${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 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");
+      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 +15295,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) };
     }
   });
 
@@ -15049,6 +15395,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       // Categories
       listCategories,
       updateCategoryBudget,
+      moveCategoryBudget,
       // Payees
       listPayees,
       // Transactions
@@ -15069,7 +15416,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_fb321989-7b03-4647-9b5e-64822784cb35.ts
   if (!globalThis.__openTabs) {
     globalThis.__openTabs = {};
   } else {
@@ -15285,5 +15632,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="dddcb110d2a66a4da7a57c142d0df2274bcc27f65c27b3a8d89c81d827caa8de";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