estatehelm 1.0.8 → 1.0.9

package/dist/index.js

@@ -933,6 +933,16 @@ async function deriveWrapKey(recoveryKeyBytes, serverWrapSecret, info = "hearthc
   return wrapKey;
 }
 
+// ../types/src/contacts.ts
+function getContactDisplayName(contact, fallback = "") {
+  const personName = [contact.first_name, contact.last_name].filter(Boolean).join(" ");
+  const companyName = contact.company_name || "";
+  if (personName && companyName) {
+    return `${personName} / ${companyName}`;
+  }
+  return personName || companyName || fallback;
+}
+
 // ../types/src/keys.ts
 var DEFAULT_KEY_BUNDLE_ALG = "ECDH-P-521";
 
@@ -1725,45 +1735,7 @@ async function getPrivateKey() {
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_types5 = require("@modelcontextprotocol/sdk/types.js");
-
-// src/filter.ts
-var REDACTION_RULES = {
-  // Password entries
-  password: ["password", "notes"],
-  // Identity documents
-  identity: ["password", "recoveryKey", "securityAnswers"],
-  // Financial accounts
-  bank_account: ["accountNumber", "routingNumber"],
-  investment: ["accountNumber"],
-  // Access codes
-  access_code: ["code", "pin"],
-  // Credentials (show last 4 of document number)
-  credential: ["documentNumber"]
-};
-var PARTIAL_REDACTION_FIELDS = ["documentNumber", "accountNumber"];
-var REDACTED = "[REDACTED]";
-function redactEntity(entity, entityType, mode) {
-  if (mode === "full") {
-    return entity;
-  }
-  const fieldsToRedact = REDACTION_RULES[entityType] || [];
-  if (fieldsToRedact.length === 0) {
-    return entity;
-  }
-  const redacted = { ...entity };
-  for (const field of fieldsToRedact) {
-    if (field in redacted && redacted[field] != null) {
-      const value = redacted[field];
-      if (PARTIAL_REDACTION_FIELDS.includes(field) && typeof value === "string" && value.length > 4) {
-        redacted[field] = `****${value.slice(-4)}`;
-      } else {
-        redacted[field] = REDACTED;
-      }
-    }
-  }
-  return redacted;
-}
+var import_types42 = require("@modelcontextprotocol/sdk/types.js");
 
 // ../cache-sqlite/src/sqliteStore.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
@@ -2478,194 +2450,2623 @@ async function downloadAndDecryptFile(client, householdId, fileId, entityId, ent
     mimeType
   );
   return {
-    data: decrypted.data,
-    dataBase64: base64Encode(decrypted.data),
+    bytes: decrypted.bytes,
+    dataBase64: base64Encode(decrypted.bytes),
     mimeType: decrypted.mimeType,
     fileName: fileInfo.fileName
   };
 }
 
-// src/server.ts
-async function startServer(mode) {
-  const config = loadConfig();
-  const privacyMode = mode || config.defaultMode;
-  console.error(`[MCP] Starting server in ${privacyMode} mode`);
-  const client = await getAuthenticatedClient();
-  if (!client) {
-    console.error("[MCP] Not logged in. Run: estatehelm login");
-    process.exit(1);
-  }
-  const privateKey = await getPrivateKey();
-  if (!privateKey) {
-    console.error("[MCP] Failed to load encryption keys. Run: estatehelm login");
-    process.exit(1);
+// src/resources/households.ts
+async function listHouseholds() {
+  return getHouseholds();
+}
+async function getHousehold(householdId) {
+  const households = await getHouseholds();
+  return households.find((h) => h.id === householdId) || null;
+}
+async function getHouseholdSummary(householdId, privateKey, getDecryptedEntities2) {
+  const households = await getHouseholds();
+  const household = households.find((h) => h.id === householdId);
+  if (!household) {
+    return null;
   }
-  await initCache();
-  console.error("[MCP] Checking for updates...");
-  const synced = await syncIfNeeded(client, privateKey);
-  if (synced) {
-    console.error("[MCP] Cache updated");
-  } else {
-    console.error("[MCP] Cache is up to date");
+  const entityTypes = [
+    "pet",
+    "property",
+    "vehicle",
+    "contact",
+    "insurance",
+    "bank_account",
+    "investment",
+    "subscription",
+    "maintenance_task",
+    "password",
+    "access_code"
+  ];
+  const counts = {};
+  for (const type of entityTypes) {
+    const entities = await getDecryptedEntities2(householdId, type, privateKey);
+    counts[type] = entities.length;
   }
-  const server = new import_server.Server(
-    {
-      name: "estatehelm",
-      version: "1.0.0"
+  return {
+    household: {
+      id: household.id,
+      name: household.name
     },
-    {
-      capabilities: {
-        resources: {},
-        tools: {},
-        prompts: {}
+    counts,
+    totalEntities: Object.values(counts).reduce((a, b) => a + b, 0)
+  };
+}
+
+// src/filter.ts
+var REDACTION_RULES = {
+  // Password entries
+  password: ["password", "notes"],
+  // Identity documents
+  identity: ["password", "recovery_key", "security_answers"],
+  // Financial accounts
+  bank_account: ["account_number", "routing_number"],
+  investment: ["account_number"],
+  // Access codes
+  access_code: ["code", "pin"],
+  // Credentials (show last 4 of document number)
+  credential: ["document_number"]
+};
+var PARTIAL_REDACTION_FIELDS = ["document_number", "account_number"];
+var REDACTED = "[REDACTED]";
+function redactEntity(entity, entityType, mode) {
+  if (mode === "full") {
+    return entity;
+  }
+  const fieldsToRedact = REDACTION_RULES[entityType] || [];
+  if (fieldsToRedact.length === 0) {
+    return entity;
+  }
+  const redacted = { ...entity };
+  for (const field of fieldsToRedact) {
+    if (field in redacted && redacted[field] != null) {
+      const value = redacted[field];
+      if (PARTIAL_REDACTION_FIELDS.includes(field) && typeof value === "string" && value.length > 4) {
+        redacted[field] = `****${value.slice(-4)}`;
+      } else {
+        redacted[field] = REDACTED;
       }
     }
-  );
-  server.setRequestHandler(import_types5.ListResourcesRequestSchema, async () => {
-    const households = await getHouseholds();
-    const resources = [
-      {
-        uri: "estatehelm://households",
-        name: "All Households",
-        description: "List of all households you have access to",
-        mimeType: "application/json"
-      }
-    ];
-    for (const household of households) {
-      resources.push({
-        uri: `estatehelm://households/${household.id}`,
-        name: household.name,
-        description: `Household: ${household.name}`,
-        mimeType: "application/json"
-      });
-      const entityTypes = [
-        "pet",
-        "property",
-        "vehicle",
-        "contact",
-        "insurance",
-        "bank_account",
-        "investment",
-        "subscription",
-        "maintenance_task",
-        "password",
-        "access_code",
-        "document",
-        "medical",
-        "prescription",
-        "credential",
-        "utility"
-      ];
-      for (const type of entityTypes) {
-        resources.push({
-          uri: `estatehelm://households/${household.id}/${type}`,
-          name: `${household.name} - ${formatEntityType(type)}`,
-          description: `${formatEntityType(type)} in ${household.name}`,
-          mimeType: "application/json"
-        });
-      }
+  }
+  return redacted;
+}
+
+// ../list-data/src/computedFields.ts
+function getExpiryStatus(days) {
+  if (days < 0) return "expired";
+  if (days <= 30) return "expiring_soon";
+  return "ok";
+}
+
+// ../utils/src/dateHelpers.ts
+function calculateDetailedAge(dateOfBirth) {
+  if (!dateOfBirth) return null;
+  const birth = new Date(dateOfBirth);
+  const today = /* @__PURE__ */ new Date();
+  let years = today.getFullYear() - birth.getFullYear();
+  let months = today.getMonth() - birth.getMonth();
+  if (today.getDate() < birth.getDate()) {
+    months--;
+  }
+  if (months < 0) {
+    years--;
+    months += 12;
+  }
+  const fractionalYears = years + months / 12;
+  return { years, months, fractionalYears };
+}
+function calculateCatHumanYears(catAge) {
+  if (catAge <= 0) return 0;
+  if (catAge < 1) return Math.round(catAge * 15);
+  if (catAge < 2) return Math.round(15 + (catAge - 1) * 9);
+  return Math.round(24 + (catAge - 2) * 4);
+}
+function calculateDogHumanYears(dogAge, size = "medium") {
+  if (dogAge <= 0) return 0;
+  if (dogAge < 1) return Math.round(dogAge * 15);
+  if (dogAge < 2) return Math.round(15 + (dogAge - 1) * 9);
+  const yearlyRate = size === "small" ? 4 : size === "large" ? 6 : 5;
+  return Math.round(24 + (dogAge - 2) * yearlyRate);
+}
+function parseDateLocal(dateStr) {
+  const match = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (match) {
+    const [, year, month, day] = match;
+    return new Date(parseInt(year), parseInt(month) - 1, parseInt(day));
+  }
+  return new Date(dateStr);
+}
+function daysUntil(dateStr) {
+  const targetDate = parseDateLocal(dateStr);
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  const diffTime = targetDate.getTime() - today.getTime();
+  return Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+}
+
+// ../utils/src/search/searchEngine.ts
+var DEFAULT_OPTIONS = {
+  minQueryLength: 1,
+  maxPerGroup: 5,
+  maxTotal: 25,
+  includeTypes: [],
+  excludeTypes: []
+};
+function scoreMatch(query, text) {
+  if (!query || !text) return 0;
+  const queryLower = query.toLowerCase().trim();
+  const textLower = text.toLowerCase();
+  if (queryLower.length === 0) return 0;
+  if (textLower === queryLower) {
+    return 100;
+  }
+  if (textLower.startsWith(queryLower)) {
+    return 75;
+  }
+  const words = textLower.split(/\s+/);
+  for (const word of words) {
+    if (word.startsWith(queryLower)) {
+      return 50;
     }
-    return { resources };
-  });
-  server.setRequestHandler(import_types5.ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    const parsed = parseResourceUri(uri);
-    if (!parsed) {
-      throw new Error(`Invalid resource URI: ${uri}`);
+  }
+  if (textLower.includes(queryLower)) {
+    return 25;
+  }
+  return 0;
+}
+function scoreEntity(entity, query) {
+  const matchedFields = [];
+  let bestScore = 0;
+  const nameScore = scoreMatch(query, entity.name);
+  if (nameScore > 0) {
+    matchedFields.push("name");
+    bestScore = Math.max(bestScore, nameScore);
+  }
+  if (entity.subtitle) {
+    const subtitleScore = scoreMatch(query, entity.subtitle);
+    if (subtitleScore > 0) {
+      matchedFields.push("subtitle");
+      bestScore = Math.max(bestScore, subtitleScore * 0.9);
     }
-    let content;
-    if (parsed.type === "households" && !parsed.householdId) {
-      content = await getHouseholds();
-    } else if (parsed.type === "households" && parsed.householdId && !parsed.entityType) {
-      const households = await getHouseholds();
-      content = households.find((h) => h.id === parsed.householdId);
-      if (!content) {
-        throw new Error(`Household not found: ${parsed.householdId}`);
+  }
+  if (entity.keywords && entity.keywords.length > 0) {
+    for (const keyword of entity.keywords) {
+      const keywordScore = scoreMatch(query, keyword);
+      if (keywordScore > 0) {
+        if (!matchedFields.includes("keywords")) {
+          matchedFields.push("keywords");
+        }
+        bestScore = Math.max(bestScore, keywordScore * 0.8);
       }
-    } else if (parsed.householdId && parsed.entityType) {
-      const entities = await getDecryptedEntities(parsed.householdId, parsed.entityType, privateKey);
-      content = entities.map((e) => redactEntity(e, parsed.entityType, privacyMode));
-    } else {
-      throw new Error(`Unsupported resource: ${uri}`);
     }
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(content, null, 2)
-        }
-      ]
-    };
+  }
+  return { score: bestScore, matchedFields };
+}
+function searchEntities(entities, query, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const trimmedQuery = query.trim();
+  if (trimmedQuery.length < opts.minQueryLength) {
+    return [];
+  }
+  let filteredEntities = entities;
+  if (opts.includeTypes && opts.includeTypes.length > 0) {
+    filteredEntities = filteredEntities.filter(
+      (e) => opts.includeTypes.includes(e.entityType)
+    );
+  }
+  if (opts.excludeTypes && opts.excludeTypes.length > 0) {
+    filteredEntities = filteredEntities.filter(
+      (e) => !opts.excludeTypes.includes(e.entityType)
+    );
+  }
+  if (trimmedQuery.length === 0) {
+    const results2 = filteredEntities.map((entity) => ({
+      entity,
+      score: 1,
+      // Default score for unfiltered results
+      matchedFields: []
+    }));
+    results2.sort((a, b) => (a.entity?.name || "").localeCompare(b.entity?.name || ""));
+    return results2.slice(0, opts.maxTotal);
+  }
+  const results = [];
+  for (const entity of filteredEntities) {
+    const { score, matchedFields } = scoreEntity(entity, trimmedQuery);
+    if (score > 0) {
+      results.push({ entity, score, matchedFields });
+    }
+  }
+  results.sort((a, b) => {
+    if (b.score !== a.score) {
+      return b.score - a.score;
+    }
+    return (a.entity?.name || "").localeCompare(b.entity?.name || "");
   });
-  server.setRequestHandler(import_types5.ListToolsRequestSchema, async () => {
-    return {
-      tools: [
-        {
-          name: "search_entities",
-          description: "Search across all entities in EstateHelm",
-          inputSchema: {
-            type: "object",
-            properties: {
-              query: {
-                type: "string",
-                description: "Search query"
-              },
-              householdId: {
-                type: "string",
-                description: "Optional: Limit search to a specific household"
-              },
-              entityType: {
-                type: "string",
-                description: "Optional: Limit search to a specific entity type"
-              }
-            },
-            required: ["query"]
-          }
-        },
-        {
-          name: "get_household_summary",
-          description: "Get a summary of a household including counts and key dates",
-          inputSchema: {
-            type: "object",
-            properties: {
-              householdId: {
-                type: "string",
-                description: "The household ID"
-              }
-            },
-            required: ["householdId"]
-          }
-        },
-        {
-          name: "get_expiring_items",
-          description: "Get items expiring within a given number of days",
-          inputSchema: {
-            type: "object",
-            properties: {
-              days: {
-                type: "number",
-                description: "Number of days to look ahead (default: 30)"
-              },
-              householdId: {
-                type: "string",
-                description: "Optional: Limit to a specific household"
-              }
-            }
-          }
-        },
-        {
-          name: "refresh",
-          description: "Force refresh of cached data from the server",
-          inputSchema: {
-            type: "object",
-            properties: {}
-          }
-        },
-        {
-          name: "get_file",
-          description: "Download and decrypt a file attachment. Returns base64-encoded file data that can be saved to disk.",
-          inputSchema: {
+  return results.slice(0, opts.maxTotal);
+}
+
+// ../utils/src/search/entityIndexer.ts
+function formatLabel(value) {
+  if (!value) return "";
+  return value.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function getVehicleName(vehicle) {
+  if (vehicle.name) return vehicle.name;
+  const parts = [vehicle.year, vehicle.make, vehicle.model].filter(Boolean);
+  return parts.length > 0 ? parts.join(" ") : "Vehicle";
+}
+function getContactName(contact) {
+  const fullName = [contact.first_name, contact.last_name].filter(Boolean).join(" ");
+  if (fullName) return fullName;
+  if (contact.company_name) return contact.company_name;
+  return "Contact";
+}
+function getSubscriptionName(sub) {
+  return sub.custom_name || formatLabel(sub.provider) || "Subscription";
+}
+function getServiceName(service) {
+  return service.service_name || service.name || "Service";
+}
+function getPropertyName(property) {
+  if (property.name) return property.name;
+  if (property.street_address) {
+    return property.city ? `${property.street_address}, ${property.city}` : property.street_address;
+  }
+  return "Property";
+}
+function getPetName(pet) {
+  return pet.name || "Pet";
+}
+function getAccessCodeName(code) {
+  return code.name || code.description || "Access Code";
+}
+function getFinancialAccountName(account) {
+  return account.name || account.account_name || account.nickname || (account.institution ? `${account.institution} Account` : "Financial Account");
+}
+function getInsuranceName(policy) {
+  return policy.name || policy.policy_name || policy.provider || formatLabel(policy.type) || "Insurance";
+}
+function getValuableName(valuable) {
+  return valuable.name || valuable.item_name || valuable.description || "Valuable";
+}
+function getMaintenanceTaskName(task) {
+  return task.name || task.title || task.task_name || "Maintenance Task";
+}
+function getDeviceName(device) {
+  return device.name || device.device_name || "Device";
+}
+function getPetVetVisitName(visit) {
+  return visit.name || visit.clinic_name || visit.reason || "Vet Visit";
+}
+function getPetHealthName(record) {
+  return record.name || (record.record_type ? formatLabel(record.record_type) : "Health Record");
+}
+function getVehicleMaintenanceName(record) {
+  return record.name || record.service_type || record.description || "Maintenance Record";
+}
+function getVehicleServiceVisitName(visit) {
+  return visit.name || visit.shop_name || visit.description || "Service Visit";
+}
+function getEntityDisplayName(entityType, data) {
+  switch (entityType) {
+    case "property":
+      return getPropertyName(data);
+    case "vehicle":
+      return getVehicleName(data);
+    case "pet":
+      return getPetName(data);
+    case "contact":
+      return getContactName(data);
+    case "subscription":
+      return getSubscriptionName(data);
+    case "service":
+      return getServiceName(data);
+    case "insurance":
+      return getInsuranceName(data);
+    case "valuable":
+      return getValuableName(data);
+    case "financial_account":
+      return getFinancialAccountName(data);
+    case "access_code":
+      return getAccessCodeName(data);
+    case "maintenance_task":
+      return getMaintenanceTaskName(data);
+    case "device":
+      return getDeviceName(data);
+    case "pet_vet_visit":
+      return getPetVetVisitName(data);
+    case "pet_health":
+      return getPetHealthName(data);
+    case "vehicle_maintenance":
+      return getVehicleMaintenanceName(data);
+    case "vehicle_service_visit":
+      return getVehicleServiceVisitName(data);
+    case "home_improvement":
+      return data.name || data.title || data.project_name || "Home Improvement";
+    case "credential":
+      return data.name || data.title || "Credential";
+    case "password":
+      return data.name || data.site_name || data.title || "Password";
+    case "legal":
+      return data.name || data.title || "Legal Document";
+    case "military_record":
+      return data.name || data.title || "Military Record";
+    case "education_record":
+      return data.name || data.institution || data.title || "Education Record";
+    case "travel":
+      return data.name || data.document_type || "Travel Document";
+    case "identity":
+      return data.name || data.document_type || "Identity Document";
+    case "document":
+      return data.name || data.title || data.file_name || "Document";
+    default:
+      return data.name || data.title || entityType;
+  }
+}
+function indexProperty(property) {
+  const subtitle = property.city && property.state ? `${property.city}, ${property.state}` : property.street_address || "Property";
+  return {
+    id: property.id,
+    entityType: "property",
+    name: property.name,
+    subtitle,
+    // Synonyms: house, home for natural language searches
+    keywords: [property.street_address, property.city, property.state, "house", "home"].filter(Boolean),
+    icon: "Home",
+    route: `/property?id=${property.id}`,
+    routeParams: { id: property.id }
+  };
+}
+function indexVehicle(vehicle) {
+  const subtitle = formatLabel(vehicle.vehicle_type) || "Vehicle";
+  const synonyms = [];
+  if (vehicle.vehicle_type === "car" || vehicle.vehicle_type === "sedan" || vehicle.vehicle_type === "suv" || vehicle.vehicle_type === "truck") {
+    synonyms.push("car", "auto", "automobile");
+  }
+  if (vehicle.vehicle_type === "motorcycle") {
+    synonyms.push("bike", "motorbike");
+  }
+  if (vehicle.vehicle_type === "boat") {
+    synonyms.push("watercraft");
+  }
+  const keywords = [vehicle.make, vehicle.model, vehicle.license_plate, ...synonyms].filter(Boolean);
+  return {
+    id: vehicle.id,
+    entityType: "vehicle",
+    name: getVehicleName(vehicle),
+    subtitle,
+    keywords,
+    icon: "Car",
+    route: `/vehicle?id=${vehicle.id}`,
+    routeParams: { id: vehicle.id }
+  };
+}
+function indexPet(pet) {
+  const speciesLabel = formatLabel(pet.species);
+  const subtitle = pet.breed ? `${speciesLabel} - ${pet.breed}` : speciesLabel || "Pet";
+  const synonyms = [];
+  if (pet.species === "dog" || pet.species === "canine") {
+    synonyms.push("dog", "puppy", "pup");
+  } else if (pet.species === "cat" || pet.species === "feline") {
+    synonyms.push("cat", "kitty", "kitten");
+  } else if (pet.species === "bird") {
+    synonyms.push("bird", "parrot");
+  } else if (pet.species === "fish") {
+    synonyms.push("fish", "aquarium");
+  }
+  return {
+    id: pet.id,
+    entityType: "pet",
+    name: pet.name,
+    subtitle,
+    keywords: [pet.breed, pet.species, ...synonyms].filter(Boolean),
+    icon: "PawPrint",
+    route: `/pet?id=${pet.id}`,
+    routeParams: { id: pet.id }
+  };
+}
+function indexContact(contact, linkedEntities) {
+  const subtitle = contact.specialty ? `${formatLabel(contact.type)} - ${contact.specialty}` : formatLabel(contact.type) || "Contact";
+  const linkedNames = linkedEntities?.map((e) => e.name) || [];
+  const linkedRoles = linkedEntities?.map((e) => formatLabel(e.role)) || [];
+  return {
+    id: contact.id,
+    entityType: "contact",
+    name: getContactName(contact),
+    subtitle,
+    keywords: [
+      contact.company_name,
+      contact.first_name,
+      contact.last_name,
+      contact.specialty,
+      ...linkedNames,
+      ...linkedRoles
+    ].filter(Boolean),
+    icon: "Phone",
+    route: `/contact?id=${contact.id}`,
+    routeParams: { id: contact.id }
+  };
+}
+function indexSubscription(sub) {
+  const subtitle = formatLabel(sub.category) || "Subscription";
+  const displayName = getSubscriptionName(sub);
+  const keywords = [];
+  if (sub.provider) {
+    keywords.push(sub.provider);
+    const formatted = formatLabel(sub.provider);
+    if (formatted !== sub.provider) {
+      keywords.push(formatted);
+    }
+  }
+  if (sub.custom_name) {
+    keywords.push(sub.custom_name);
+  }
+  if (sub.category) {
+    keywords.push(sub.category);
+  }
+  const formattedProvider = formatLabel(sub.provider);
+  const searchableName = sub.provider && formattedProvider !== displayName ? `${displayName} (${formattedProvider})` : displayName;
+  return {
+    id: sub.id,
+    entityType: "subscription",
+    name: searchableName,
+    subtitle,
+    keywords,
+    icon: "CreditCard",
+    route: `/subscription?id=${sub.id}`,
+    routeParams: { id: sub.id }
+  };
+}
+function indexService(service) {
+  const subtitle = formatLabel(service.service_type) || "Service";
+  return {
+    id: service.id,
+    entityType: "service",
+    name: getServiceName(service),
+    subtitle,
+    keywords: [service.provider, service.service_type].filter(Boolean),
+    icon: "Wrench",
+    route: `/service?id=${service.id}`,
+    routeParams: { id: service.id }
+  };
+}
+function indexInsurance(policy, coveredAssetNames) {
+  const subtitle = formatLabel(policy.type) || "Insurance";
+  const keywords = [policy.policy_number, policy.type, ...coveredAssetNames || []].filter(Boolean);
+  return {
+    id: policy.id,
+    entityType: "insurance",
+    name: policy.provider || "Insurance Policy",
+    subtitle,
+    keywords,
+    icon: "Shield",
+    route: `/insurance?id=${policy.id}`,
+    routeParams: { id: policy.id }
+  };
+}
+function indexValuable(valuable) {
+  const categoryLabel = valuable.category === "other" && valuable.other_category ? valuable.other_category : formatLabel(valuable.category);
+  const subtitle = categoryLabel || "Valuable";
+  return {
+    id: valuable.id,
+    entityType: "valuable",
+    name: valuable.name,
+    subtitle,
+    keywords: [valuable.category, valuable.other_category].filter(Boolean),
+    icon: "Gem",
+    route: `/valuables?id=${valuable.id}`,
+    routeParams: { id: valuable.id }
+  };
+}
+function indexFinancialAccount(account, ownerNames) {
+  const typeLabel = formatLabel(account.account_type) || "Financial Account";
+  let subtitle = typeLabel;
+  if (ownerNames && ownerNames.length > 0) {
+    subtitle = `${typeLabel} \u2022 ${ownerNames.join(", ")}`;
+  }
+  return {
+    id: account.id,
+    entityType: "financial_account",
+    name: account.nickname || account.institution || "Financial Account",
+    subtitle,
+    keywords: [account.institution, account.account_type, ...ownerNames || []].filter(Boolean),
+    icon: "Landmark",
+    route: `/financial?id=${account.id}`,
+    routeParams: { id: account.id }
+  };
+}
+function indexCredential(credential, personName) {
+  const subtypeLabel = formatLabel(credential.credential_subtype);
+  const typeLabel = subtypeLabel || formatLabel(credential.credential_type) || "Credential";
+  const subtitle = personName ? `${typeLabel} \u2022 ${personName}` : typeLabel;
+  const synonyms = ["id", "identification"];
+  const subtype = credential.credential_subtype?.toLowerCase() || "";
+  const type = credential.credential_type?.toLowerCase() || "";
+  if (subtype.includes("passport")) {
+    synonyms.push("passport", "travel document");
+  }
+  if (subtype.includes("driver") || subtype.includes("license")) {
+    synonyms.push("license", "drivers license", "DL", "driving license");
+  }
+  if (subtype.includes("ssn") || subtype.includes("social_security")) {
+    synonyms.push("social security", "SSN", "social security number");
+  }
+  if (type.includes("professional") || type.includes("license")) {
+    synonyms.push("license", "certification", "cert");
+  }
+  if (subtype.includes("birth") || subtype.includes("certificate")) {
+    synonyms.push("birth certificate", "certificate");
+  }
+  return {
+    id: credential.id,
+    entityType: "credential",
+    name: credential.name,
+    subtitle,
+    keywords: [credential.credential_type, credential.credential_subtype, credential.issuing_authority, personName, ...synonyms].filter(Boolean),
+    icon: "CreditCard",
+    route: `/credentials?id=${credential.id}`,
+    routeParams: { id: credential.id }
+  };
+}
+function indexPetVetVisit(visit, petName) {
+  const procedureNames = visit.procedures?.map((p) => p.name).filter(Boolean).join(", ");
+  let subtitle = petName || "Vet Visit";
+  if (petName && procedureNames) {
+    subtitle = `${petName} \u2022 ${procedureNames}`;
+  } else if (procedureNames) {
+    subtitle = procedureNames;
+  }
+  return {
+    id: visit.id,
+    entityType: "pet_vet_visit",
+    name: visit.name || `${petName || "Pet"} - Vet Visit`,
+    subtitle,
+    keywords: [petName, ...visit.procedures?.map((p) => p.name).filter(Boolean) || []].filter(Boolean),
+    icon: "Stethoscope",
+    route: `/pet?tab=health&id=${visit.id}`,
+    routeParams: { tab: "health", id: visit.id }
+  };
+}
+function indexVehicleService(service, vehicleName) {
+  const serviceNames = service.services?.map((s) => s.name).filter(Boolean).join(", ");
+  let subtitle = vehicleName || "Service Record";
+  if (vehicleName && serviceNames) {
+    subtitle = `${vehicleName} \u2022 ${serviceNames}`;
+  } else if (serviceNames) {
+    subtitle = serviceNames;
+  }
+  return {
+    id: service.id,
+    entityType: "vehicle_service",
+    name: service.name || `${vehicleName || "Vehicle"} - Service`,
+    subtitle,
+    keywords: [vehicleName, ...service.services?.map((s) => s.name).filter(Boolean) || []].filter(Boolean),
+    icon: "FileText",
+    route: `/vehicle-maintenance?id=${service.id}`,
+    routeParams: { id: service.id }
+  };
+}
+function indexMaintenanceTask(task, assetName) {
+  const subtitle = assetName ? `${formatLabel(task.category)} - ${assetName}` : formatLabel(task.category) || "Maintenance";
+  return {
+    id: task.id,
+    entityType: "maintenance_task",
+    name: task.name || task.title || "Maintenance Task",
+    subtitle,
+    keywords: [task.category].filter(Boolean),
+    icon: "ClipboardList",
+    route: `/maintenance?id=${task.id}`,
+    routeParams: { id: task.id }
+  };
+}
+function indexLegalDocument(doc, residentNames) {
+  const typeLabel = formatLabel(doc.type) || "Legal Document";
+  let subtitle = typeLabel;
+  if (residentNames && residentNames.length > 0) {
+    subtitle = `${typeLabel} \u2022 ${residentNames.join(", ")}`;
+  }
+  const synonyms = ["doc", "document", "legal", "paperwork"];
+  return {
+    id: doc.id,
+    entityType: "legal_document",
+    name: doc.name,
+    subtitle,
+    keywords: [doc.type, ...residentNames || [], ...synonyms].filter(Boolean),
+    icon: "FileText",
+    route: `/legal?id=${doc.id}`,
+    routeParams: { id: doc.id }
+  };
+}
+function indexAccessCode(code, propertyName) {
+  const subtitle = propertyName ? `${formatLabel(code.code_type)} - ${propertyName}` : formatLabel(code.code_type) || "Access Code";
+  return {
+    id: code.id,
+    entityType: "access_code",
+    name: code.name,
+    subtitle,
+    keywords: [code.code_type].filter(Boolean),
+    icon: "Key",
+    route: `/property?tab=access&id=${code.id}`,
+    routeParams: { tab: "access", id: code.id }
+  };
+}
+function indexDevice(device) {
+  const subtitle = device.brand ? `${formatLabel(device.device_type)} - ${device.brand}` : formatLabel(device.device_type) || "Device";
+  return {
+    id: device.id,
+    entityType: "device",
+    name: device.name,
+    subtitle,
+    keywords: [device.device_type, device.brand, device.model].filter(Boolean),
+    icon: "Wifi",
+    route: `/device?id=${device.id}`,
+    routeParams: { id: device.id }
+  };
+}
+function indexPerson(person) {
+  const subtitle = formatLabel(person.relationship_type) || formatLabel(person.person_type) || "Person";
+  return {
+    id: person.id,
+    entityType: "person",
+    name: person.name,
+    subtitle,
+    keywords: [person.person_type, person.relationship_type].filter(Boolean),
+    icon: "User",
+    route: `/people?id=${person.id}`,
+    routeParams: { id: person.id }
+  };
+}
+function indexHealthRecord(record, ownerName) {
+  const subtitle = ownerName ? `${formatLabel(record.record_type)} - ${ownerName}` : formatLabel(record.record_type) || "Health Record";
+  return {
+    id: record.id,
+    entityType: "health_record",
+    name: record.name,
+    subtitle,
+    keywords: [record.record_type, record.provider].filter(Boolean),
+    icon: "Heart",
+    route: `/records?type=health_record&id=${record.id}`,
+    routeParams: { id: record.id }
+  };
+}
+function indexEducationRecord(record, personName) {
+  const subtitle = personName ? `${formatLabel(record.record_type)} - ${personName}` : record.institution || formatLabel(record.record_type) || "Education Record";
+  return {
+    id: record.id,
+    entityType: "education_record",
+    name: record.name,
+    subtitle,
+    keywords: [record.record_type, record.institution, record.level, record.field_of_study].filter(Boolean),
+    icon: "GraduationCap",
+    route: `/records?type=education_record&id=${record.id}`,
+    routeParams: { id: record.id }
+  };
+}
+function indexMilitaryRecord(record, personName) {
+  const branchLabel = formatLabel(record.branch);
+  const subtitle = personName ? `${branchLabel || formatLabel(record.record_type)} - ${personName}` : branchLabel || formatLabel(record.record_type) || "Military Record";
+  return {
+    id: record.id,
+    entityType: "military_record",
+    name: record.name,
+    subtitle,
+    keywords: [record.record_type, record.branch, record.rank].filter(Boolean),
+    icon: "Medal",
+    route: `/records?type=military_record&id=${record.id}`,
+    routeParams: { id: record.id }
+  };
+}
+function indexHomeImprovement(improvement, propertyName) {
+  const subtitle = propertyName ? `${formatLabel(improvement.improvement_type)} - ${propertyName}` : formatLabel(improvement.improvement_type) || "Home Improvement";
+  return {
+    id: improvement.id,
+    entityType: "home_improvement",
+    name: improvement.name,
+    subtitle,
+    keywords: [improvement.improvement_type].filter(Boolean),
+    icon: "Hammer",
+    route: `/home-improvement/${improvement.id}`,
+    routeParams: { id: improvement.id }
+  };
+}
+function indexTaxYear(taxYear, filerNames) {
+  let subtitle = taxYear.country || "Tax Year";
+  if (filerNames && filerNames.length > 0) {
+    subtitle = filerNames.join(", ");
+  }
+  return {
+    id: taxYear.id,
+    entityType: "tax_year",
+    name: `${taxYear.year} Tax Year`,
+    subtitle,
+    keywords: [taxYear.country, String(taxYear.year), ...filerNames || []].filter(Boolean),
+    icon: "Receipt",
+    route: `/taxes?id=${taxYear.id}`,
+    routeParams: { id: taxYear.id }
+  };
+}
+function indexMembershipRecord(record, personName) {
+  const typeLabel = formatLabel(record.membership_type);
+  let subtitle = typeLabel || "Membership";
+  if (personName) {
+    subtitle = record.level ? `${typeLabel} \u2022 ${record.level} \u2022 ${personName}` : `${typeLabel} \u2022 ${personName}`;
+  } else if (record.level) {
+    subtitle = `${typeLabel} \u2022 ${record.level}`;
+  }
+  return {
+    id: record.id,
+    entityType: "membership_record",
+    name: record.name,
+    subtitle,
+    keywords: [record.membership_type, record.membership_number, record.level, record.alliance, personName].filter(Boolean),
+    icon: "Ticket",
+    route: `/records?type=membership_record&id=${record.id}`,
+    routeParams: { id: record.id }
+  };
+}
+function indexAllEntities(data) {
+  const entities = [];
+  const propertyNames = /* @__PURE__ */ new Map();
+  const vehicleNames = /* @__PURE__ */ new Map();
+  const petNames = /* @__PURE__ */ new Map();
+  const personNames = /* @__PURE__ */ new Map();
+  data.properties?.forEach((p) => propertyNames.set(p.id, p.name));
+  data.vehicles?.forEach((v) => vehicleNames.set(v.id, getVehicleName(v)));
+  data.pets?.forEach((p) => petNames.set(p.id, p.name));
+  data.people?.forEach((p) => personNames.set(p.id, p.name));
+  const contactLinkedEntities = /* @__PURE__ */ new Map();
+  const addContactLink = (contactId, name, role) => {
+    const existing = contactLinkedEntities.get(contactId) || [];
+    existing.push({ name, role });
+    contactLinkedEntities.set(contactId, existing);
+  };
+  data.pets?.forEach((pet) => {
+    pet.contact_relationships?.forEach((rel) => {
+      addContactLink(rel.contact_id, pet.name, rel.role);
+    });
+  });
+  data.vehicles?.forEach((vehicle) => {
+    const name = getVehicleName(vehicle);
+    vehicle.contact_relationships?.forEach((rel) => {
+      addContactLink(rel.contact_id, name, rel.role);
+    });
+  });
+  data.properties?.forEach((property) => {
+    property.contact_relationships?.forEach((rel) => {
+      addContactLink(rel.contact_id, property.name, rel.role);
+    });
+  });
+  data.properties?.forEach((p) => entities.push(indexProperty(p)));
+  data.vehicles?.forEach((v) => entities.push(indexVehicle(v)));
+  data.pets?.forEach((p) => entities.push(indexPet(p)));
+  data.contacts?.forEach((c) => {
+    const linkedEntities = contactLinkedEntities.get(c.id);
+    entities.push(indexContact(c, linkedEntities));
+  });
+  data.subscriptions?.forEach((s) => entities.push(indexSubscription(s)));
+  data.services?.forEach((s) => entities.push(indexService(s)));
+  data.insurancePolicies?.forEach((policy) => {
+    const coveredAssetNames = [];
+    policy.relationships?.forEach((rel) => {
+      if (rel.entity_type === "property") {
+        const name = propertyNames.get(rel.entity_id);
+        if (name) coveredAssetNames.push(name);
+      } else if (rel.entity_type === "vehicle") {
+        const name = vehicleNames.get(rel.entity_id);
+        if (name) coveredAssetNames.push(name);
+      } else if (rel.entity_type === "pet") {
+        const name = petNames.get(rel.entity_id);
+        if (name) coveredAssetNames.push(name);
+      }
+    });
+    if (policy.property_id) {
+      const name = propertyNames.get(policy.property_id);
+      if (name && !coveredAssetNames.includes(name)) coveredAssetNames.push(name);
+    }
+    if (policy.vehicle_id) {
+      const name = vehicleNames.get(policy.vehicle_id);
+      if (name && !coveredAssetNames.includes(name)) coveredAssetNames.push(name);
+    }
+    if (policy.pet_id) {
+      const name = petNames.get(policy.pet_id);
+      if (name && !coveredAssetNames.includes(name)) coveredAssetNames.push(name);
+    }
+    entities.push(indexInsurance(policy, coveredAssetNames.length > 0 ? coveredAssetNames : void 0));
+  });
+  data.valuables?.forEach((v) => entities.push(indexValuable(v)));
+  data.financialAccounts?.forEach((a) => {
+    const ownerNames = a.owner_ids?.map((id) => personNames.get(id)).filter(Boolean);
+    entities.push(indexFinancialAccount(a, ownerNames));
+  });
+  data.credentials?.forEach((c) => {
+    const personName = c.person_id ? personNames.get(c.person_id) : void 0;
+    entities.push(indexCredential(c, personName));
+  });
+  data.petVetVisits?.forEach((v) => {
+    const petName = v.pet_id ? petNames.get(v.pet_id) : void 0;
+    entities.push(indexPetVetVisit(v, petName));
+  });
+  data.vehicleServices?.forEach((s) => {
+    const vehicleName = s.vehicle_id ? vehicleNames.get(s.vehicle_id) : void 0;
+    entities.push(indexVehicleService(s, vehicleName));
+  });
+  data.maintenanceTasks?.forEach((t) => {
+    let assetName;
+    if (t.property_id) assetName = propertyNames.get(t.property_id);
+    else if (t.vehicle_id) assetName = vehicleNames.get(t.vehicle_id);
+    entities.push(indexMaintenanceTask(t, assetName));
+  });
+  data.legalDocuments?.forEach((d) => {
+    const residentNames = d.resident_ids?.map((id) => personNames.get(id)).filter(Boolean);
+    entities.push(indexLegalDocument(d, residentNames));
+  });
+  data.accessCodes?.forEach((c) => {
+    const propertyName = c.property_id ? propertyNames.get(c.property_id) : void 0;
+    entities.push(indexAccessCode(c, propertyName));
+  });
+  data.devices?.forEach((d) => entities.push(indexDevice(d)));
+  data.people?.forEach((p) => entities.push(indexPerson(p)));
+  data.healthRecords?.forEach((r) => {
+    let ownerName;
+    if (r.person_id) ownerName = personNames.get(r.person_id);
+    else if (r.pet_id) ownerName = petNames.get(r.pet_id);
+    entities.push(indexHealthRecord(r, ownerName));
+  });
+  data.educationRecords?.forEach((r) => {
+    const personName = r.person_id ? personNames.get(r.person_id) : void 0;
+    entities.push(indexEducationRecord(r, personName));
+  });
+  data.militaryRecords?.forEach((r) => {
+    const personName = r.person_id ? personNames.get(r.person_id) : void 0;
+    entities.push(indexMilitaryRecord(r, personName));
+  });
+  data.membershipRecords?.forEach((r) => {
+    const personName = r.person_id ? personNames.get(r.person_id) : void 0;
+    entities.push(indexMembershipRecord(r, personName));
+  });
+  data.homeImprovements?.forEach((i) => {
+    const propertyName = i.property_id ? propertyNames.get(i.property_id) : void 0;
+    entities.push(indexHomeImprovement(i, propertyName));
+  });
+  data.taxYears?.forEach((t) => {
+    const filerNames = t.filer_ids?.map((id) => personNames.get(id)).filter(Boolean);
+    entities.push(indexTaxYear(t, filerNames));
+  });
+  return entities;
+}
+
+// ../list-data/src/adapters/contactAdapter.ts
+function getContactComputedFields(contact) {
+  const computed = {
+    displayName: getContactDisplayName(contact)
+  };
+  if (contact.type) {
+    computed.formattedType = contact.type.charAt(0).toUpperCase() + contact.type.slice(1).replace(/_/g, " ");
+  }
+  return computed;
+}
+
+// ../list-data/src/adapters/insuranceAdapter.ts
+function getInsuranceComputedFields(policy) {
+  const computed = {
+    displayName: policy.provider || "Insurance Policy"
+  };
+  if (policy.expiration_date) {
+    computed.daysUntilExpiry = daysUntil(policy.expiration_date);
+    computed.expiryStatus = getExpiryStatus(computed.daysUntilExpiry);
+  }
+  if (policy.type) {
+    computed.formattedType = policy.type.charAt(0).toUpperCase() + policy.type.slice(1);
+  }
+  return computed;
+}
+
+// ../list-data/src/adapters/petAdapter.ts
+function getPetComputedFields(pet) {
+  const computed = {
+    displayName: pet.name
+  };
+  const detailedAge = calculateDetailedAge(pet.date_of_birth);
+  if (detailedAge !== null && !pet.memorialized_at) {
+    if (detailedAge.years < 1) {
+      const months = detailedAge.months || 1;
+      computed.age = `${months} month${months !== 1 ? "s" : ""}`;
+    } else {
+      computed.age = `${detailedAge.years} year${detailedAge.years !== 1 ? "s" : ""}`;
+    }
+    if (pet.species === "cat") {
+      computed.humanYears = calculateCatHumanYears(detailedAge.fractionalYears);
+    } else if (pet.species === "dog") {
+      let size = "medium";
+      const weightHistory = pet.weight_history || [];
+      const latestWeight = weightHistory.length > 0 ? [...weightHistory].sort((a, b) => b.date.localeCompare(a.date))[0] : null;
+      const weightInLbs = latestWeight ? latestWeight.unit === "kg" ? latestWeight.weight * 2.20462 : latestWeight.weight : pet.weight_lbs;
+      if (weightInLbs) {
+        if (weightInLbs < 20) size = "small";
+        else if (weightInLbs > 50) size = "large";
+      }
+      computed.humanYears = calculateDogHumanYears(detailedAge.fractionalYears, size);
+    }
+  }
+  if (pet.species) {
+    computed.formattedType = pet.species.charAt(0).toUpperCase() + pet.species.slice(1).replace(/_/g, " ");
+  }
+  return computed;
+}
+
+// ../list-data/src/adapters/vehicleAdapter.ts
+function getVehicleComputedFields(vehicle) {
+  const parts = [vehicle.year, vehicle.make, vehicle.model].filter(Boolean);
+  const displayName = parts.length > 0 ? parts.join(" ") : vehicle.name || "Vehicle";
+  const computed = {
+    displayName
+  };
+  if (vehicle.registration_expiration) {
+    const monthNum = parseInt(vehicle.registration_expiration, 10);
+    if (monthNum >= 1 && monthNum <= 12) {
+      const now = /* @__PURE__ */ new Date();
+      const currentYear = now.getFullYear();
+      const currentMonth = now.getMonth() + 1;
+      let targetYear = currentYear;
+      if (monthNum < currentMonth) {
+        targetYear = currentYear + 1;
+      }
+      const expirationDate = new Date(targetYear, monthNum, 0);
+      const daysUntil2 = Math.ceil((expirationDate.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
+      computed.daysUntilExpiry = daysUntil2;
+      if (daysUntil2 < 0) {
+        computed.expiryStatus = "expired";
+      } else if (daysUntil2 <= 30) {
+        computed.expiryStatus = "expiring_soon";
+      } else {
+        computed.expiryStatus = "ok";
+      }
+    }
+  }
+  const vehicleType = vehicle.vehicle_type || vehicle.type;
+  if (vehicleType) {
+    computed.formattedType = vehicleType.charAt(0).toUpperCase() + vehicleType.slice(1);
+  }
+  return computed;
+}
+
+// ../list-data/src/data/propertyMaintenanceTemplates.json
+var propertyMaintenanceTemplates_default = [
+  {
+    id: "smoke-detector-maintenance",
+    name: "Smoke & CO Detector Maintenance",
+    description: "Monthly: Test all detectors. Annually: Replace batteries",
+    category: "safety",
+    applicableTo: "property",
+    conditions: {},
+    defaultFrequency: {
+      type: "recurring",
+      interval: "monthly"
+    },
+    priority: "critical",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 15,
+    whyImportant: "Life-saving devices must be functional - test monthly, replace batteries yearly"
+  },
+  {
+    id: "hvac-filter-replacement",
+    name: "Replace HVAC Air Filter",
+    description: "Change air filter in heating/cooling system to maintain efficiency",
+    category: "hvac",
+    applicableTo: "property",
+    conditions: {
+      hasAC: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "monthly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 10,
+    whyImportant: "Dirty filters reduce efficiency by up to 15% and worsen air quality"
+  },
+  {
+    id: "furnace-inspection",
+    name: "Furnace Inspection & Service",
+    description: "Professional inspection and cleaning of gas furnace",
+    category: "hvac",
+    applicableTo: "property",
+    conditions: {
+      hasGasFurnace: true
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "fall",
+      monthsNorthern: [9],
+      monthsSouthern: [3]
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Ensures safe operation and prevents carbon monoxide leaks"
+  },
+  {
+    id: "ac-service",
+    name: "Air Conditioning Service",
+    description: "Professional AC inspection and cleaning",
+    category: "hvac",
+    applicableTo: "property",
+    conditions: {
+      hasAC: true
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "spring",
+      monthsNorthern: [4, 5],
+      monthsSouthern: [10, 11]
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Maintains efficiency and prevents breakdowns in summer heat"
+  },
+  {
+    id: "gutter-cleaning-fall",
+    name: "Clean Gutters (Fall)",
+    description: "Remove leaves and debris from gutters and downspouts",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      hasGutters: true,
+      propertyType: ["single_family", "townhouse"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "fall",
+      monthsNorthern: [10, 11],
+      monthsSouthern: [4, 5]
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Clogged gutters can cause water damage to foundation and roof"
+  },
+  {
+    id: "gutter-cleaning-spring",
+    name: "Clean Gutters (Spring)",
+    description: "Remove debris accumulated over winter",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      hasGutters: true,
+      propertyType: ["single_family", "townhouse"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "spring",
+      monthsNorthern: [4, 5],
+      monthsSouthern: [10, 11]
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Spring runoff needs clear gutters to prevent water damage"
+  },
+  {
+    id: "roof-moss-removal",
+    name: "Remove Roof Moss",
+    description: "Clean moss and debris from roof shingles",
+    category: "roof",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      climate: ["marine", "humid_subtropical", "humid_continental"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 240,
+    whyImportant: "Moss damages shingles and reduces roof lifespan significantly"
+  },
+  {
+    id: "roof-inspection",
+    name: "Inspect Roof",
+    description: "Check for damaged shingles, leaks, and wear",
+    category: "roof",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Early detection of roof damage prevents expensive interior water damage"
+  },
+  {
+    id: "pool-chemistry-check",
+    name: "Check Pool Chemistry",
+    description: "Test and balance pH, chlorine, and alkalinity levels",
+    category: "pool",
+    applicableTo: "property",
+    conditions: {
+      hasPool: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "weekly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Prevents algae growth and keeps water safe for swimming"
+  },
+  {
+    id: "pool-filter-cleaning",
+    name: "Clean Pool Filter",
+    description: "Backwash or clean pool filter system",
+    category: "pool",
+    applicableTo: "property",
+    conditions: {
+      hasPool: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "monthly"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Keeps water circulation efficient and clear"
+  },
+  {
+    id: "pool-winterization",
+    name: "Winterize Pool",
+    description: "Close pool for winter: drain, add antifreeze, install cover",
+    category: "pool",
+    applicableTo: "property",
+    conditions: {
+      hasPool: true,
+      winterSeverity: ["moderate", "severe"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "fall",
+      monthsNorthern: [10],
+      monthsSouthern: [4]
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Prevents freeze damage to pool equipment and plumbing"
+  },
+  {
+    id: "pool-opening",
+    name: "Open Pool for Summer",
+    description: "Remove cover, refill, balance chemicals, start equipment",
+    category: "pool",
+    applicableTo: "property",
+    conditions: {
+      hasPool: true,
+      winterSeverity: ["moderate", "severe"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "spring",
+      monthsNorthern: [4, 5],
+      monthsSouthern: [10, 11]
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Proper opening prevents damage and ensures safe swimming"
+  },
+  {
+    id: "sprinkler-system-blowout",
+    name: "Blow Out Sprinkler System",
+    description: "Clear water from sprinkler lines to prevent freeze damage",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      hasSprinklerSystem: true,
+      winterSeverity: ["moderate", "severe"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "fall",
+      monthsNorthern: [10],
+      monthsSouthern: [4]
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Frozen water in lines can cause $1000+ in repairs"
+  },
+  {
+    id: "sprinkler-system-startup",
+    name: "Start Up Sprinkler System",
+    description: "Turn on system, check for leaks, adjust spray patterns",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      hasSprinklerSystem: true,
+      winterSeverity: ["moderate", "severe"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "spring",
+      monthsNorthern: [4, 5],
+      monthsSouthern: [10, 11]
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Catch leaks early before they waste water and money"
+  },
+  {
+    id: "chimney-cleaning-inspection",
+    name: "Chimney Cleaning & Inspection",
+    description: "Remove creosote buildup and inspect for damage",
+    category: "safety",
+    applicableTo: "property",
+    conditions: {
+      hasFireplace: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Prevents chimney fires caused by creosote buildup"
+  },
+  {
+    id: "septic-tank-pumping",
+    name: "Pump Septic Tank",
+    description: "Professional septic tank pumping and inspection",
+    category: "plumbing",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family"],
+      hasSepticSystem: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      customMonths: 36
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Prevents backup and expensive drain field replacement ($10,000+)"
+  },
+  {
+    id: "water-heater-flush",
+    name: "Flush Water Heater",
+    description: "Drain sediment from water heater tank",
+    category: "plumbing",
+    applicableTo: "property",
+    conditions: {},
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Removes sediment buildup that reduces efficiency and lifespan"
+  },
+  {
+    id: "deck-staining",
+    name: "Stain/Seal Deck",
+    description: "Apply protective stain or sealant to wood deck",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      hasDeck: true,
+      deckMaterial: ["wood"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      customMonths: 24
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 480,
+    whyImportant: "Protects wood from rot and extends deck life by years"
+  },
+  {
+    id: "driveway-sealing",
+    name: "Seal Asphalt Driveway",
+    description: "Apply sealcoat to protect asphalt surface",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      hasDriveway: true,
+      drivewayMaterial: ["asphalt"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      customMonths: 24
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 360,
+    whyImportant: "Prevents cracks and extends driveway life significantly"
+  },
+  {
+    id: "power-wash-exterior",
+    name: "Power Wash Home Exterior",
+    description: "Clean siding, walkways, and deck to remove dirt and mildew",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 240,
+    whyImportant: "Prevents mildew damage and maintains curb appeal"
+  },
+  {
+    id: "window-caulking",
+    name: "Inspect & Recaulk Windows",
+    description: "Check window caulking and reapply where needed",
+    category: "exterior",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      customMonths: 24
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Prevents water infiltration and improves energy efficiency"
+  },
+  {
+    id: "dryer-vent-cleaning",
+    name: "Clean Dryer Vent",
+    description: "Remove lint buildup from dryer vent ductwork",
+    category: "appliances",
+    applicableTo: "property",
+    conditions: {},
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Prevents fire hazard and improves dryer efficiency"
+  },
+  {
+    id: "refrigerator-coil-cleaning",
+    name: "Clean Refrigerator Coils",
+    description: "Vacuum dust from refrigerator condenser coils",
+    category: "appliances",
+    applicableTo: "property",
+    conditions: {},
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Improves efficiency and extends refrigerator lifespan"
+  },
+  {
+    id: "lawn-mowing",
+    name: "Mow Lawn",
+    description: "Cut grass to maintain healthy lawn appearance",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      lawnSize: ["small", "medium"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "weekly"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Keeps lawn healthy and property looking well-maintained"
+  },
+  {
+    id: "lawn-fertilizing-spring",
+    name: "Fertilize Lawn (Spring)",
+    description: "Apply spring fertilizer to promote growth",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      lawnSize: ["small", "medium"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "spring",
+      monthsNorthern: [4, 5],
+      monthsSouthern: [10, 11]
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Promotes healthy growth and green color"
+  },
+  {
+    id: "lawn-fertilizing-fall",
+    name: "Fertilize Lawn (Fall)",
+    description: "Apply fall fertilizer to strengthen roots",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      lawnSize: ["small", "medium"]
+    },
+    defaultFrequency: {
+      type: "seasonal",
+      season: "fall",
+      monthsNorthern: [9, 10],
+      monthsSouthern: [3, 4]
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Strengthens roots for winter and early spring growth"
+  },
+  {
+    id: "lawn-aeration",
+    name: "Aerate Lawn",
+    description: "Core aerate lawn to improve water and nutrient absorption",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      lawnSize: ["medium"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Reduces soil compaction and promotes healthier grass"
+  },
+  {
+    id: "tree-trimming",
+    name: "Trim Trees & Shrubs",
+    description: "Prune dead branches and shape trees/shrubs",
+    category: "landscaping",
+    applicableTo: "property",
+    conditions: {
+      propertyType: ["single_family", "townhouse"],
+      treeCount: ["few"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Prevents damage from falling branches and promotes healthy growth"
+  },
+  {
+    id: "well-pump-testing",
+    name: "Test Well Pump",
+    description: "Check well pump operation and water quality",
+    category: "plumbing",
+    applicableTo: "property",
+    conditions: {
+      hasWell: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Catches pump issues early before complete failure"
+  },
+  {
+    id: "basement-sump-pump-test",
+    name: "Test Sump Pump",
+    description: "Pour water into sump pit to ensure pump activates properly",
+    category: "plumbing",
+    applicableTo: "property",
+    conditions: {
+      hasBasement: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 15,
+    whyImportant: "Prevents basement flooding during heavy rain"
+  },
+  {
+    id: "solar-panel-cleaning",
+    name: "Clean Solar Panels",
+    description: "Remove dirt, pollen, bird droppings, and debris from solar panels",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasSolarPanels: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Dirty panels can reduce energy output by 20-25%"
+  },
+  {
+    id: "solar-panel-visual-inspection",
+    name: "Inspect Solar Panels",
+    description: "Check panels for cracks, hotspots, discoloration, loose connections, and debris buildup",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasSolarPanels: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Early detection of damage prevents costly repairs and output loss"
+  },
+  {
+    id: "solar-inverter-inspection",
+    name: "Check Solar Inverter",
+    description: "Verify inverter is functioning properly, check status lights and error codes",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasSolarPanels: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "monthly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 10,
+    whyImportant: "Inverter failure stops all energy production - catch issues early"
+  },
+  {
+    id: "solar-system-professional-inspection",
+    name: "Professional Solar System Inspection",
+    description: "Full system inspection including wiring, connections, mounting, and performance analysis",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasSolarPanels: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      customMonths: 24
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Ensures system operates at peak efficiency and maintains warranty"
+  },
+  {
+    id: "home-battery-visual-inspection",
+    name: "Inspect Home Battery System",
+    description: "Check battery unit for damage, leaks, unusual sounds, and ensure ventilation is clear",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasHomeBattery: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 15,
+    whyImportant: "Early detection of battery issues prevents safety hazards and costly damage"
+  },
+  {
+    id: "home-battery-firmware-update",
+    name: "Check Battery Firmware Updates",
+    description: "Check manufacturer app for firmware updates and apply if available",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasHomeBattery: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 15,
+    whyImportant: "Updates improve performance, fix bugs, and enhance safety features"
+  },
+  {
+    id: "home-battery-professional-inspection",
+    name: "Professional Battery System Inspection",
+    description: "Full inspection of battery connections, performance testing, and state of health analysis",
+    category: "solar",
+    applicableTo: "property",
+    conditions: {
+      hasHomeBattery: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Ensures safe operation and optimal battery health for longevity"
+  },
+  {
+    id: "window-cleaning",
+    name: "Clean Windows",
+    description: "Clean interior and exterior windows for improved visibility and appearance",
+    category: "interior",
+    applicableTo: "property",
+    conditions: {},
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Clean windows improve natural light and curb appeal"
+  },
+  {
+    id: "carpet-cleaning",
+    name: "Carpet Cleaning",
+    description: "Deep clean carpets to remove dirt, stains, and allergens",
+    category: "interior",
+    applicableTo: "property",
+    conditions: {
+      hasCarpets: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 240,
+    whyImportant: "Extends carpet life, improves air quality, and removes allergens"
+  }
+];
+
+// ../list-data/src/data/vehicleMaintenanceTemplates.json
+var vehicleMaintenanceTemplates_default = [
+  {
+    id: "oil-change",
+    name: "Oil Change",
+    description: "Change engine oil and oil filter",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"],
+      engineType: ["gasoline", "diesel", "hybrid", "plugin_hybrid"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "critical",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Regular oil changes prevent engine wear and extend vehicle life. Most critical maintenance task."
+  },
+  {
+    id: "tire-rotation",
+    name: "Tire Rotation",
+    description: "Rotate tires to ensure even wear",
+    category: "tires",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Even tire wear extends tire life by up to 20% and improves safety and fuel efficiency."
+  },
+  {
+    id: "brake-inspection",
+    name: "Brake Inspection",
+    description: "Inspect brake pads, rotors, and fluid",
+    category: "brakes",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "motorcycle", "rv"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Brake failure is life-threatening. Regular inspection prevents accidents and costly repairs."
+  },
+  {
+    id: "air-filter-replacement",
+    name: "Replace Engine Air Filter",
+    description: "Replace engine air filter for optimal performance",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"],
+      engineType: ["gasoline", "diesel", "hybrid", "plugin_hybrid"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 15,
+    whyImportant: "Clean air filter improves fuel economy by up to 10% and engine performance."
+  },
+  {
+    id: "cabin-air-filter",
+    name: "Replace Cabin Air Filter",
+    description: "Replace cabin air filter for clean interior air",
+    category: "interior",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 10,
+    whyImportant: "Filters out pollen, dust, and pollutants for healthier cabin air."
+  },
+  {
+    id: "battery-check",
+    name: "Battery Test",
+    description: "Test battery voltage and terminals, clean corrosion",
+    category: "electrical",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 20,
+    whyImportant: "Prevents unexpected breakdowns. Most batteries last 3-5 years."
+  },
+  {
+    id: "coolant-flush",
+    name: "Coolant Flush",
+    description: "Drain and replace engine coolant/antifreeze",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"],
+      engineType: ["gasoline", "diesel", "hybrid", "plugin_hybrid"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Prevents engine overheating and corrosion. Critical for engine longevity."
+  },
+  {
+    id: "transmission-service",
+    name: "Transmission Service",
+    description: "Change transmission fluid and filter",
+    category: "drivetrain",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"],
+      transmissionType: ["automatic", "cvt"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 120,
+    whyImportant: "Extends transmission life. Transmission replacement can cost $3,000-$8,000."
+  },
+  {
+    id: "spark-plugs",
+    name: "Replace Spark Plugs",
+    description: "Replace spark plugs for optimal ignition",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"],
+      engineType: ["gasoline", "hybrid", "plugin_hybrid"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Improves fuel efficiency, reduces emissions, and ensures smooth engine operation."
+  },
+  {
+    id: "wiper-blades",
+    name: "Replace Wiper Blades",
+    description: "Replace windshield wiper blades",
+    category: "exterior",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car", "rv"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 10,
+    whyImportant: "Essential for visibility and safety in rain and snow."
+  },
+  {
+    id: "wheel-alignment",
+    name: "Wheel Alignment",
+    description: "Check and adjust wheel alignment",
+    category: "tires",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "routine",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Prevents uneven tire wear and improves handling and fuel economy."
+  },
+  {
+    id: "timing-belt",
+    name: "Timing Belt Replacement",
+    description: "Replace timing belt (if applicable)",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car"],
+      engineType: ["gasoline", "diesel"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 240,
+    whyImportant: "Timing belt failure can cause catastrophic engine damage. Check your owner's manual for mileage interval (typically 60k-100k miles)."
+  },
+  {
+    id: "differential-service",
+    name: "Differential Service",
+    description: "Change differential fluid",
+    category: "drivetrain",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car"],
+      driveType: ["awd", "4wd", "rwd"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "routine",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Maintains drivetrain efficiency and prevents costly differential failure."
+  },
+  {
+    id: "motorcycle-chain-maintenance",
+    name: "Chain Cleaning & Lubrication",
+    description: "Clean and lubricate motorcycle chain",
+    category: "drivetrain",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["motorcycle"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "monthly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Prevents chain wear and ensures safe operation. Chain failure can be dangerous."
+  },
+  {
+    id: "bicycle-tune-up",
+    name: "Bicycle Tune-Up",
+    description: "Check brakes, gears, tire pressure, chain lubrication",
+    category: "general",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["bicycle"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Ensures safe and efficient riding. Prevents accidents and costly repairs."
+  },
+  {
+    id: "ev-battery-check",
+    name: "EV Battery Health Check",
+    description: "Professional battery health diagnostic",
+    category: "electrical",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car"],
+      engineType: ["electric", "plugin_hybrid"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Monitors battery degradation and ensures warranty compliance."
+  },
+  {
+    id: "winter-tire-swap",
+    name: "Winter Tire Installation",
+    description: "Swap to winter tires for cold weather",
+    category: "tires",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["car"],
+      hasWinterTires: true
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 90,
+    whyImportant: "Winter tires dramatically improve traction and safety in snow and ice."
+  },
+  {
+    id: "boat-engine-oil",
+    name: "Boat Engine Oil Change",
+    description: "Change engine oil and filter for boat motor",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "critical",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Marine engines operate in harsh conditions. Regular oil changes prevent corrosion and extend engine life."
+  },
+  {
+    id: "boat-hull-inspection",
+    name: "Hull Inspection & Cleaning",
+    description: "Inspect hull for damage, clean barnacles and growth",
+    category: "exterior",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 180,
+    whyImportant: "Hull growth reduces fuel efficiency and speed. Damage can lead to costly repairs or sinking."
+  },
+  {
+    id: "boat-winterization",
+    name: "Winterization",
+    description: "Prepare boat for winter storage: drain water, stabilize fuel, protect engine",
+    category: "general",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "critical",
+    skillLevel: "professional",
+    estimatedTimeMinutes: 240,
+    whyImportant: "Prevents freeze damage to engine and systems. Skipping winterization can cause thousands in repairs."
+  },
+  {
+    id: "boat-battery-maintenance",
+    name: "Battery Check & Charging",
+    description: "Test battery, check terminals, maintain charge",
+    category: "electrical",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Dead battery leaves you stranded on water. Marine batteries need regular charging and maintenance."
+  },
+  {
+    id: "boat-safety-equipment",
+    name: "Safety Equipment Inspection",
+    description: "Check life jackets, fire extinguishers, flares, first aid kit",
+    category: "safety",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "critical",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 45,
+    whyImportant: "Required by law and essential for safety. Expired flares and damaged life jackets can be life-threatening."
+  },
+  {
+    id: "boat-bilge-pump",
+    name: "Bilge Pump Test",
+    description: "Test bilge pump operation and clean intake",
+    category: "safety",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "quarterly"
+    },
+    priority: "critical",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 20,
+    whyImportant: "Bilge pump failure can lead to sinking. Regular testing ensures it works when needed."
+  },
+  {
+    id: "boat-propeller-inspection",
+    name: "Propeller Inspection",
+    description: "Check propeller for damage, dings, fishing line",
+    category: "drivetrain",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "biannually"
+    },
+    priority: "important",
+    skillLevel: "diy_easy",
+    estimatedTimeMinutes: 30,
+    whyImportant: "Damaged props reduce performance and fuel efficiency. Can damage transmission if left unchecked."
+  },
+  {
+    id: "boat-fuel-system",
+    name: "Fuel System Maintenance",
+    description: "Add fuel stabilizer, check fuel lines and water separator",
+    category: "engine",
+    applicableTo: "vehicle",
+    conditions: {
+      vehicleType: ["boat"]
+    },
+    defaultFrequency: {
+      type: "recurring",
+      interval: "yearly"
+    },
+    priority: "important",
+    skillLevel: "diy_moderate",
+    estimatedTimeMinutes: 60,
+    whyImportant: "Marine fuel degrades quickly. Prevents engine damage from bad fuel and water contamination."
+  }
+];
+
+// ../list-data/src/adapters/maintenanceAdapter.ts
+var ALL_MAINTENANCE_TEMPLATES = [
+  ...propertyMaintenanceTemplates_default,
+  ...vehicleMaintenanceTemplates_default
+];
+
+// ../list-data/src/adapters/subscriptionAdapter.ts
+function getSubscriptionComputedFields(sub) {
+  const computed = {
+    displayName: sub.name || sub.provider || "Subscription"
+  };
+  if (sub.expiration_date) {
+    computed.daysUntilExpiry = daysUntil(sub.expiration_date);
+    computed.expiryStatus = getExpiryStatus(computed.daysUntilExpiry);
+  }
+  if (sub.category) {
+    computed.formattedType = sub.category.charAt(0).toUpperCase() + sub.category.slice(1).replace(/_/g, " ");
+  }
+  return computed;
+}
+
+// ../list-data/src/adapters/credentialAdapter.ts
+function getCredentialComputedFields(credential) {
+  const computed = {
+    displayName: credential.name || credential.credential_type || "Credential"
+  };
+  if (credential.expiration_date) {
+    computed.daysUntilExpiry = daysUntil(credential.expiration_date);
+    computed.expiryStatus = getExpiryStatus(computed.daysUntilExpiry);
+  }
+  if (credential.credential_type) {
+    computed.formattedType = credential.credential_type.charAt(0).toUpperCase() + credential.credential_type.slice(1).replace(/_/g, " ");
+  }
+  return computed;
+}
+
+// src/enrichment.ts
+function getComputedFields(entity, entityType) {
+  switch (entityType) {
+    case "pet":
+      return getPetComputedFields(entity);
+    case "vehicle":
+      return getVehicleComputedFields(entity);
+    case "insurance":
+      return getInsuranceComputedFields(entity);
+    case "subscription":
+      return getSubscriptionComputedFields(entity);
+    case "contact":
+      return getContactComputedFields(entity);
+    case "credential":
+      return getCredentialComputedFields(entity);
+    default:
+      return {
+        displayName: getEntityDisplayName(entityType, entity)
+      };
+  }
+}
+function enrichEntity(entity, entityType) {
+  const computed = getComputedFields(entity, entityType);
+  return { ...entity, _computed: computed };
+}
+function enrichEntities(entities, entityType) {
+  return entities.map((entity) => enrichEntity(entity, entityType));
+}
+
+// src/resources/entities.ts
+var ENTITY_TYPES = [
+  "pet",
+  "property",
+  "vehicle",
+  "contact",
+  "insurance",
+  "bank_account",
+  "investment",
+  "subscription",
+  "maintenance_task",
+  "password",
+  "access_code",
+  "document",
+  "medical",
+  "prescription",
+  "credential",
+  "utility"
+];
+async function getEntities(householdId, entityType, privateKey, privacyMode) {
+  const entities = await getDecryptedEntities(householdId, entityType, privateKey);
+  return enrichEntities(entities, entityType).map(
+    (entity) => redactEntity(entity, entityType, privacyMode)
+  );
+}
+async function getExpiringItems(days, householdId, privateKey) {
+  const households = await getHouseholds();
+  const searchHouseholds = householdId ? households.filter((h) => h.id === householdId) : households;
+  const now = /* @__PURE__ */ new Date();
+  const cutoff = new Date(now.getTime() + days * 24 * 60 * 60 * 1e3);
+  const expiring = [];
+  for (const household of searchHouseholds) {
+    const insurance = await getDecryptedEntities(household.id, "insurance", privateKey);
+    for (const policy of insurance) {
+      if (policy.expiration_date) {
+        const expires = new Date(policy.expiration_date);
+        if (expires <= cutoff) {
+          expiring.push({
+            householdId: household.id,
+            householdName: household.name,
+            type: "insurance",
+            name: policy.name || policy.provider || policy.policy_number,
+            expiresAt: policy.expiration_date,
+            daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
+          });
+        }
+      }
+    }
+    const vehicles = await getDecryptedEntities(household.id, "vehicle", privateKey);
+    for (const vehicle of vehicles) {
+      const vehicleName = `${vehicle.year || ""} ${vehicle.make || ""} ${vehicle.model || ""}`.trim() || "Vehicle";
+      if (vehicle.registration_expiration) {
+        const expires = new Date(vehicle.registration_expiration);
+        if (expires <= cutoff) {
+          expiring.push({
+            householdId: household.id,
+            householdName: household.name,
+            type: "vehicle_registration",
+            name: vehicleName,
+            expiresAt: vehicle.registration_expiration,
+            daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
+          });
+        }
+      }
+      if (vehicle.tabs_expiration) {
+        const expires = new Date(vehicle.tabs_expiration);
+        if (expires <= cutoff) {
+          expiring.push({
+            householdId: household.id,
+            householdName: household.name,
+            type: "vehicle_tabs",
+            name: vehicleName,
+            expiresAt: vehicle.tabs_expiration,
+            daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
+          });
+        }
+      }
+    }
+    const subscriptions = await getDecryptedEntities(household.id, "subscription", privateKey);
+    for (const sub of subscriptions) {
+      if (sub.expiration_date) {
+        const expires = new Date(sub.expiration_date);
+        if (expires <= cutoff) {
+          expiring.push({
+            householdId: household.id,
+            householdName: household.name,
+            type: "subscription",
+            name: sub.name || sub.custom_name || sub.provider || sub.service_name,
+            expiresAt: sub.expiration_date,
+            daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
+          });
+        }
+      }
+    }
+    const credentials = await getDecryptedEntities(household.id, "credential", privateKey);
+    for (const cred of credentials) {
+      if (cred.expiration_date) {
+        const expires = new Date(cred.expiration_date);
+        if (expires <= cutoff) {
+          expiring.push({
+            householdId: household.id,
+            householdName: household.name,
+            type: "credential",
+            name: cred.name || cred.credential_type,
+            expiresAt: cred.expiration_date,
+            daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
+          });
+        }
+      }
+    }
+  }
+  expiring.sort((a, b) => a.daysUntil - b.daysUntil);
+  return expiring;
+}
+
+// src/tools/search.ts
+async function buildEntitiesData(householdId, privateKey) {
+  const entityTypeMapping = {
+    property: "properties",
+    vehicle: "vehicles",
+    pet: "pets",
+    contact: "contacts",
+    subscription: "subscriptions",
+    service: "services",
+    insurance: "insurancePolicies",
+    valuable: "valuables",
+    bank_account: "financialAccounts",
+    investment: "financialAccounts",
+    credential: "credentials",
+    maintenance_task: "maintenanceTasks",
+    access_code: "accessCodes",
+    device: "devices",
+    person: "people",
+    pet_vet_visit: "petVetVisits",
+    vehicle_service: "vehicleServices",
+    legal: "legalDocuments",
+    health_record: "healthRecords",
+    education_record: "educationRecords",
+    military_record: "militaryRecords",
+    membership_record: "membershipRecords",
+    home_improvement: "homeImprovements",
+    tax_year: "taxYears"
+  };
+  const data = {};
+  const entityTypes = Object.keys(entityTypeMapping);
+  for (const type of entityTypes) {
+    try {
+      const entities = await getDecryptedEntities(householdId, type, privateKey);
+      if (entities.length > 0) {
+        const propName = entityTypeMapping[type];
+        const existing = data[propName] || [];
+        data[propName] = [...existing, ...entities];
+      }
+    } catch {
+    }
+  }
+  return data;
+}
+async function executeSearch(params, privateKey, privacyMode) {
+  const { query, householdId, entityType } = params;
+  const households = await getHouseholds();
+  const searchHouseholds = householdId ? households.filter((h) => h.id === householdId) : households;
+  const results = [];
+  for (const household of searchHouseholds) {
+    const entitiesData = await buildEntitiesData(household.id, privateKey);
+    const searchableEntities = indexAllEntities(entitiesData);
+    const searchResults = searchEntities(searchableEntities, query, {
+      maxTotal: 50,
+      includeTypes: entityType ? [entityType] : void 0
+    });
+    for (const result of searchResults) {
+      const type = result.entity.entityType;
+      const entityId = result.entity.id;
+      const entities = await getDecryptedEntities(household.id, type, privateKey);
+      const fullEntity = entities.find((e) => e.id === entityId);
+      if (fullEntity) {
+        const enriched = enrichEntity(fullEntity, type);
+        const redacted = redactEntity(enriched, type, privacyMode);
+        results.push({
+          householdId: household.id,
+          householdName: household.name,
+          entityType: type,
+          entity: redacted,
+          score: result.score,
+          matchedFields: result.matchedFields
+        });
+      }
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+
+// src/tools/files.ts
+async function executeFileDownload(client, params) {
+  const { fileId, householdId, entityId, entityType } = params;
+  try {
+    const result = await downloadAndDecryptFile(
+      client,
+      householdId,
+      fileId,
+      entityId,
+      entityType
+    );
+    return {
+      success: true,
+      fileName: result.fileName,
+      mimeType: result.mimeType,
+      size: result.bytes.length,
+      data: result.dataBase64
+    };
+  } catch (err) {
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+
+// src/server.ts
+async function startServer(mode) {
+  const config = loadConfig();
+  const privacyMode = mode || config.defaultMode;
+  console.error(`[MCP] Starting server in ${privacyMode} mode`);
+  const client = await getAuthenticatedClient();
+  if (!client) {
+    console.error("[MCP] Not logged in. Run: estatehelm login");
+    process.exit(1);
+  }
+  const privateKey = await getPrivateKey();
+  if (!privateKey) {
+    console.error("[MCP] Failed to load encryption keys. Run: estatehelm login");
+    process.exit(1);
+  }
+  await initCache();
+  console.error("[MCP] Checking for updates...");
+  const synced = await syncIfNeeded(client, privateKey);
+  if (synced) {
+    console.error("[MCP] Cache updated");
+  } else {
+    console.error("[MCP] Cache is up to date");
+  }
+  const server = new import_server.Server(
+    {
+      name: "estatehelm",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        resources: {},
+        tools: {},
+        prompts: {}
+      }
+    }
+  );
+  server.setRequestHandler(import_types42.ListResourcesRequestSchema, async () => {
+    const households = await listHouseholds();
+    const resources = [
+      {
+        uri: "estatehelm://households",
+        name: "All Households",
+        description: "List of all households you have access to",
+        mimeType: "application/json"
+      }
+    ];
+    for (const household of households) {
+      resources.push({
+        uri: `estatehelm://households/${household.id}`,
+        name: household.name,
+        description: `Household: ${household.name}`,
+        mimeType: "application/json"
+      });
+      for (const type of ENTITY_TYPES) {
+        resources.push({
+          uri: `estatehelm://households/${household.id}/${type}`,
+          name: `${household.name} - ${formatEntityType(type)}`,
+          description: `${formatEntityType(type)} in ${household.name}`,
+          mimeType: "application/json"
+        });
+      }
+    }
+    return { resources };
+  });
+  server.setRequestHandler(import_types42.ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const parsed = parseResourceUri(uri);
+    if (!parsed) {
+      throw new Error(`Invalid resource URI: ${uri}`);
+    }
+    let content;
+    if (parsed.type === "households" && !parsed.householdId) {
+      content = await listHouseholds();
+    } else if (parsed.type === "households" && parsed.householdId && !parsed.entityType) {
+      content = await getHousehold(parsed.householdId);
+      if (!content) {
+        throw new Error(`Household not found: ${parsed.householdId}`);
+      }
+    } else if (parsed.householdId && parsed.entityType) {
+      content = await getEntities(parsed.householdId, parsed.entityType, privateKey, privacyMode);
+    } else {
+      throw new Error(`Unsupported resource: ${uri}`);
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(content, null, 2)
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(import_types42.ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "search_entities",
+          description: "Search across all entities in EstateHelm. Returns results with computed fields (age, days until expiry, etc.)",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query"
+              },
+              householdId: {
+                type: "string",
+                description: "Optional: Limit search to a specific household"
+              },
+              entityType: {
+                type: "string",
+                description: "Optional: Limit search to a specific entity type"
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "get_household_summary",
+          description: "Get a summary of a household including counts and key dates",
+          inputSchema: {
+            type: "object",
+            properties: {
+              householdId: {
+                type: "string",
+                description: "The household ID"
+              }
+            },
+            required: ["householdId"]
+          }
+        },
+        {
+          name: "get_expiring_items",
+          description: "Get items expiring within a given number of days (insurance, vehicle registration, credentials, subscriptions)",
+          inputSchema: {
+            type: "object",
+            properties: {
+              days: {
+                type: "number",
+                description: "Number of days to look ahead (default: 30)"
+              },
+              householdId: {
+                type: "string",
+                description: "Optional: Limit to a specific household"
+              }
+            }
+          }
+        },
+        {
+          name: "get_file",
+          description: "Download and decrypt a file attachment. Returns base64-encoded file data that can be saved to disk.",
+          inputSchema: {
             type: "object",
             properties: {
               fileId: {
@@ -2687,231 +5088,68 @@ async function startServer(mode) {
             },
             required: ["fileId", "householdId", "entityId", "entityType"]
           }
+        },
+        {
+          name: "refresh",
+          description: "Force refresh of cached data from the server",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
         }
       ]
     };
   });
-  server.setRequestHandler(import_types5.CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(import_types42.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     switch (name) {
       case "search_entities": {
-        const { query, householdId, entityType } = args;
-        const households = await getHouseholds();
-        const searchHouseholds = householdId ? households.filter((h) => h.id === householdId) : households;
-        const results = [];
-        for (const household of searchHouseholds) {
-          const entityTypes = entityType ? [entityType] : [
-            "pet",
-            "property",
-            "vehicle",
-            "contact",
-            "insurance",
-            "bank_account",
-            "investment",
-            "subscription",
-            "maintenance_task",
-            "password",
-            "access_code"
-          ];
-          for (const type of entityTypes) {
-            const entities = await getDecryptedEntities(household.id, type, privateKey);
-            const matches = entities.filter((e) => searchEntity(e, query));
-            for (const match of matches) {
-              results.push({
-                householdId: household.id,
-                householdName: household.name,
-                entityType: type,
-                entity: redactEntity(match, type, privacyMode)
-              });
-            }
-          }
-        }
+        const results = await executeSearch(
+          args,
+          privateKey,
+          privacyMode
+        );
         return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(results, null, 2)
-            }
-          ]
+          content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
         };
       }
       case "get_household_summary": {
         const { householdId } = args;
-        const households = await getHouseholds();
-        const household = households.find((h) => h.id === householdId);
-        if (!household) {
+        const summary = await getHouseholdSummary(householdId, privateKey, getDecryptedEntities);
+        if (!summary) {
           throw new Error(`Household not found: ${householdId}`);
         }
-        const entityTypes = [
-          "pet",
-          "property",
-          "vehicle",
-          "contact",
-          "insurance",
-          "bank_account",
-          "investment",
-          "subscription",
-          "maintenance_task",
-          "password",
-          "access_code"
-        ];
-        const counts = {};
-        for (const type of entityTypes) {
-          const entities = await getDecryptedEntities(householdId, type, privateKey);
-          counts[type] = entities.length;
-        }
-        const summary = {
-          household: {
-            id: household.id,
-            name: household.name
-          },
-          counts,
-          totalEntities: Object.values(counts).reduce((a, b) => a + b, 0)
-        };
         return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(summary, null, 2)
-            }
-          ]
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
         };
       }
       case "get_expiring_items": {
         const { days = 30, householdId } = args;
-        const households = await getHouseholds();
-        const searchHouseholds = householdId ? households.filter((h) => h.id === householdId) : households;
-        const now = /* @__PURE__ */ new Date();
-        const cutoff = new Date(now.getTime() + days * 24 * 60 * 60 * 1e3);
-        const expiring = [];
-        for (const household of searchHouseholds) {
-          const insurance = await getDecryptedEntities(household.id, "insurance", privateKey);
-          for (const policy of insurance) {
-            if (policy.expiration_date) {
-              const expires = new Date(policy.expiration_date);
-              if (expires <= cutoff) {
-                expiring.push({
-                  householdId: household.id,
-                  householdName: household.name,
-                  type: "insurance",
-                  name: policy.name || policy.policy_number,
-                  expiresAt: policy.expiration_date,
-                  daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
-                });
-              }
-            }
-          }
-          const vehicles = await getDecryptedEntities(household.id, "vehicle", privateKey);
-          for (const vehicle of vehicles) {
-            const vehicleName = `${vehicle.year || ""} ${vehicle.make || ""} ${vehicle.model || ""}`.trim();
-            if (vehicle.registration_expiration) {
-              const expires = new Date(vehicle.registration_expiration);
-              if (expires <= cutoff) {
-                expiring.push({
-                  householdId: household.id,
-                  householdName: household.name,
-                  type: "vehicle_registration",
-                  name: vehicleName,
-                  expiresAt: vehicle.registration_expiration,
-                  daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
-                });
-              }
-            }
-            if (vehicle.tabs_expiration) {
-              const expires = new Date(vehicle.tabs_expiration);
-              if (expires <= cutoff) {
-                expiring.push({
-                  householdId: household.id,
-                  householdName: household.name,
-                  type: "vehicle_tabs",
-                  name: vehicleName,
-                  expiresAt: vehicle.tabs_expiration,
-                  daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
-                });
-              }
-            }
-          }
-          const subscriptions = await getDecryptedEntities(household.id, "subscription", privateKey);
-          for (const sub of subscriptions) {
-            if (sub.expiration_date) {
-              const expires = new Date(sub.expiration_date);
-              if (expires <= cutoff) {
-                expiring.push({
-                  householdId: household.id,
-                  householdName: household.name,
-                  type: "subscription",
-                  name: sub.name || sub.service_name,
-                  expiresAt: sub.expiration_date,
-                  daysUntil: Math.ceil((expires.getTime() - now.getTime()) / (24 * 60 * 60 * 1e3))
-                });
-              }
-            }
-          }
-        }
-        expiring.sort((a, b) => a.daysUntil - b.daysUntil);
+        const expiring = await getExpiringItems(days, householdId, privateKey);
         return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(expiring, null, 2)
-            }
-          ]
+          content: [{ type: "text", text: JSON.stringify(expiring, null, 2) }]
+        };
+      }
+      case "get_file": {
+        const result = await executeFileDownload(client, args);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
       }
       case "refresh": {
         const synced2 = await syncIfNeeded(client, privateKey, true);
         return {
-          content: [
-            {
-              type: "text",
-              text: synced2 ? "Cache refreshed with latest data" : "Cache was already up to date"
-            }
-          ]
+          content: [{
+            type: "text",
+            text: synced2 ? "Cache refreshed with latest data" : "Cache was already up to date"
+          }]
         };
       }
-      case "get_file": {
-        const { fileId, householdId, entityId, entityType } = args;
-        try {
-          const result = await downloadAndDecryptFile(
-            client,
-            householdId,
-            fileId,
-            entityId,
-            entityType
-          );
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: true,
-                  fileName: result.fileName,
-                  mimeType: result.mimeType,
-                  size: result.data.length,
-                  data: result.dataBase64
-                }, null, 2)
-              }
-            ]
-          };
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  success: false,
-                  error: err.message
-                }, null, 2)
-              }
-            ]
-          };
-        }
-      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
   });
-  server.setRequestHandler(import_types5.ListPromptsRequestSchema, async () => {
+  server.setRequestHandler(import_types42.ListPromptsRequestSchema, async () => {
     return {
       prompts: [
         {
@@ -2944,12 +5182,12 @@ async function startServer(mode) {
       ]
     };
   });
-  server.setRequestHandler(import_types5.GetPromptRequestSchema, async (request) => {
+  server.setRequestHandler(import_types42.GetPromptRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     switch (name) {
       case "household_summary": {
         const householdId = args?.householdId;
-        const households = await getHouseholds();
+        const households = await listHouseholds();
         const household = householdId ? households.find((h) => h.id === householdId) : households[0];
         if (!household) {
           throw new Error("No household found");
@@ -2974,7 +5212,7 @@ async function startServer(mode) {
               role: "user",
               content: {
                 type: "text",
-                text: `What items are expiring in the next ${days} days? Include insurance policies, vehicle registrations, subscriptions, and any other items with expiration dates.`
+                text: `What items are expiring in the next ${days} days? Include insurance policies, vehicle registrations, credentials (passports, licenses), subscriptions, and any other items with expiration dates.`
               }
             }
           ]
@@ -3010,27 +5248,6 @@ function parseResourceUri(uri) {
 function formatEntityType(type) {
   return type.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
 }
-function searchEntity(entity, query) {
-  const lowerQuery = query.toLowerCase();
-  const searchFields = [
-    "name",
-    "title",
-    "description",
-    "notes",
-    "make",
-    "model",
-    "policyNumber",
-    "serviceName",
-    "username",
-    "email"
-  ];
-  for (const field of searchFields) {
-    if (entity[field] && String(entity[field]).toLowerCase().includes(lowerQuery)) {
-      return true;
-    }
-  }
-  return false;
-}
 
 // src/index.ts
 var program = new import_commander.Command();