@claritylabs/cl-sdk 0.16.2 → 0.17.0

package/dist/index.mjs

@@ -1226,6 +1226,29 @@ var AuxiliaryFactSchema = z16.object({
   subject: z16.string().optional(),
   context: z16.string().optional()
 });
+var DefinitionSchema = z16.object({
+  term: z16.string(),
+  definition: z16.string(),
+  pageNumber: z16.number().optional(),
+  formNumber: z16.string().optional(),
+  formTitle: z16.string().optional(),
+  sectionRef: z16.string().optional(),
+  originalContent: z16.string().optional()
+});
+var CoveredReasonSchema = z16.object({
+  coverageName: z16.string(),
+  reasonNumber: z16.string().optional(),
+  title: z16.string().optional(),
+  content: z16.string(),
+  conditions: z16.array(z16.string()).optional(),
+  exceptions: z16.array(z16.string()).optional(),
+  appliesTo: z16.array(z16.string()).optional(),
+  pageNumber: z16.number().optional(),
+  formNumber: z16.string().optional(),
+  formTitle: z16.string().optional(),
+  sectionRef: z16.string().optional(),
+  originalContent: z16.string().optional()
+});
 var BaseDocumentFields = {
   id: z16.string(),
   carrier: z16.string(),
@@ -1236,6 +1259,8 @@ var BaseDocumentFields = {
   policyTypes: z16.array(z16.string()).optional(),
   coverages: z16.array(CoverageSchema),
   sections: z16.array(SectionSchema).optional(),
+  definitions: z16.array(DefinitionSchema).optional(),
+  coveredReasons: z16.array(CoveredReasonSchema).optional(),
   // Enriched fields (v1.2+)
   carrierLegalName: z16.string().optional(),
   carrierNaicNumber: z16.string().optional(),
@@ -1689,13 +1714,26 @@ function getDeclarationFields(doc) {
   return Array.isArray(decl?.fields) ? decl.fields : [];
 }
 function fieldMatches(fieldName, patterns) {
-  const lower = fieldName.toLowerCase().replace(/[\s_-]/g, "");
-  return patterns.some((p) => lower === p.toLowerCase().replace(/[\s_-]/g, ""));
+  const lower = normalizeFieldName(fieldName);
+  return patterns.some((p) => lower === normalizeFieldName(p));
+}
+function normalizeFieldName(fieldName) {
+  return fieldName.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function findFieldValue(fields, patterns) {
-  const match = fields.find((f) => fieldMatches(f.field, patterns));
+function findFieldValue(fields, patterns, reject) {
+  const match = fields.find((f) => fieldMatches(f.field, patterns) && !reject?.(f));
   return match?.value;
 }
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function findRawString(raw, keys) {
+  for (const key of keys) {
+    const value = stringValue(raw[key]);
+    if (value) return value;
+  }
+  return void 0;
+}
 function promoteCarrierFields(doc) {
   const raw = doc;
   if (!raw.carrierNaicNumber && raw.naicNumber) {
@@ -2011,8 +2049,126 @@ function synthesizeDeductibles(doc) {
     raw.deductibles = deductibles;
   }
 }
-var PREMIUM_PATTERNS = ["premium", "totalPremium", "annualPremium", "policyPremium", "basePremium"];
-var TOTAL_COST_PATTERNS = ["totalCost", "totalDue", "totalAmount", "totalPolicyPremium"];
+var PREMIUM_PATTERNS = [
+  "premium",
+  "premiumAmount",
+  "premium amount",
+  "totalPremium",
+  "total premium",
+  "totalPolicyPremium",
+  "total policy premium",
+  "annualPremium",
+  "annual premium",
+  "estimatedAnnualPremium",
+  "estimated annual premium",
+  "policyPremium",
+  "policy premium",
+  "basePremium",
+  "base premium",
+  "planCost",
+  "plan cost",
+  "policyCost",
+  "policy cost",
+  "premiumSubtotal",
+  "premium subtotal",
+  "subtotalPremium",
+  "subtotal premium",
+  "quotedPremium",
+  "quoted premium"
+];
+var TOTAL_COST_PATTERNS = [
+  "totalCost",
+  "total cost",
+  "total",
+  "totalDue",
+  "total due",
+  "amountPaid",
+  "amount paid",
+  "totalPaid",
+  "total paid",
+  "totalPrice",
+  "total price",
+  "totalTripCost",
+  "total trip cost",
+  "amountCharged",
+  "amount charged",
+  "amountDue",
+  "amount due",
+  "totalAmountDue",
+  "total amount due",
+  "totalAmount",
+  "total amount",
+  "grandTotal",
+  "grand total",
+  "totalPayable",
+  "total payable",
+  "totalCharges",
+  "total charges",
+  "totalPolicyCost",
+  "total policy cost"
+];
+var PREMIUM_RAW_KEYS = [
+  "premium",
+  "premiumAmount",
+  "premium_amount",
+  "totalPremium",
+  "totalPolicyPremium",
+  "annualPremium",
+  "estimatedAnnualPremium",
+  "policyPremium",
+  "basePremium",
+  "planCost",
+  "policyCost",
+  "premiumSubtotal",
+  "subtotalPremium",
+  "quotedPremium"
+];
+var TOTAL_COST_RAW_KEYS = [
+  "totalCost",
+  "total_cost",
+  "total",
+  "totalDue",
+  "amountPaid",
+  "amount_paid",
+  "totalPaid",
+  "total_paid",
+  "totalPrice",
+  "totalTripCost",
+  "amountCharged",
+  "amountDue",
+  "totalAmountDue",
+  "totalAmount",
+  "grandTotal",
+  "totalPayable",
+  "totalCharges",
+  "totalPolicyCost"
+];
+function isTaxOrFeeField(fieldName) {
+  const normalized = normalizeFieldName(fieldName);
+  return /tax|gst|hst|pst|qst|fee|surcharge|assessment|stamp|filing|inspection/.test(normalized);
+}
+function isTotalCostField(fieldName) {
+  return fieldMatches(fieldName, TOTAL_COST_PATTERNS);
+}
+function taxFeeType(fieldName) {
+  const normalized = normalizeFieldName(fieldName);
+  if (normalized.includes("tax") || ["gst", "hst", "pst", "qst"].some((token) => normalized.includes(token))) return "tax";
+  if (normalized.includes("surcharge")) return "surcharge";
+  if (normalized.includes("assessment")) return "assessment";
+  if (normalized.includes("fee") || normalized.includes("stamp") || normalized.includes("filing")) return "fee";
+  return void 0;
+}
+function titleizeFieldName(fieldName) {
+  const spaced = fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+  return spaced.replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function taxFeeKey(item) {
+  return [
+    normalizeFieldName(item.name),
+    normalizeFieldName(item.amount),
+    item.type ?? ""
+  ].join("|");
+}
 function absorbNegative(value) {
   return value.replace(/^-\s*/, "").replace(/^\(\s*(.*?)\s*\)$/, "$1");
 }
@@ -2020,16 +2176,41 @@ function promotePremium(doc) {
   const raw = doc;
   const fields = getDeclarationFields(doc);
   if (!raw.premium) {
-    const premium = findFieldValue(fields, PREMIUM_PATTERNS);
+    const premium = findRawString(raw, PREMIUM_RAW_KEYS) ?? findFieldValue(fields, PREMIUM_PATTERNS, (field) => isTaxOrFeeField(field.field));
     if (premium) raw.premium = premium;
   }
   if (!raw.totalCost) {
-    const totalCost = findFieldValue(fields, TOTAL_COST_PATTERNS);
+    const totalCost = findRawString(raw, TOTAL_COST_RAW_KEYS) ?? findFieldValue(fields, TOTAL_COST_PATTERNS);
     if (totalCost) raw.totalCost = totalCost;
   }
   if (typeof raw.premium === "string") raw.premium = absorbNegative(raw.premium);
   if (typeof raw.totalCost === "string") raw.totalCost = absorbNegative(raw.totalCost);
 }
+function synthesizeTaxesAndFees(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  if (fields.length === 0) return;
+  const existing = Array.isArray(raw.taxesAndFees) ? raw.taxesAndFees : [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of existing) {
+    if (!item?.name || !item?.amount) continue;
+    byKey.set(taxFeeKey(item), item);
+  }
+  for (const field of fields) {
+    if (!field.value?.trim()) continue;
+    if (!isTaxOrFeeField(field.field)) continue;
+    if (isTotalCostField(field.field)) continue;
+    const item = {
+      name: titleizeFieldName(field.field),
+      amount: absorbNegative(field.value),
+      ...taxFeeType(field.field) ? { type: taxFeeType(field.field) } : {}
+    };
+    byKey.set(taxFeeKey(item), item);
+  }
+  if (byKey.size > 0) {
+    raw.taxesAndFees = [...byKey.values()];
+  }
+}
 function promoteExtractedFields(doc) {
   promoteCarrierFields(doc);
   promoteBroker(doc);
@@ -2037,6 +2218,7 @@ function promoteExtractedFields(doc) {
   promoteLocations(doc);
   synthesizeLimits(doc);
   synthesizeDeductibles(doc);
+  synthesizeTaxesAndFees(doc);
   promotePremium(doc);
 }
 
@@ -2054,6 +2236,8 @@ function assembleDocument(documentId, documentType, memory) {
   const sections = memory.get("sections");
   const supplementary = memory.get("supplementary");
   const formInventory = memory.get("form_inventory");
+  const definitions = memory.get("definitions");
+  const coveredReasons = memory.get("covered_reasons");
   const classify = memory.get("classify");
   const base = {
     id: documentId,
@@ -2075,6 +2259,8 @@ function assembleDocument(documentId, documentType, memory) {
     conditions: conditions?.conditions,
     sections: sections?.sections,
     formInventory: formInventory?.forms,
+    definitions: definitions?.definitions,
+    coveredReasons: coveredReasons?.coveredReasons ?? coveredReasons?.covered_reasons,
     declarations: declarations ? sanitizeNulls(declarations) : void 0,
     ...sanitizeNulls(lossHistory ?? {})
   };
@@ -2234,6 +2420,21 @@ function collectContentFields(doc) {
       add(`conditions[${i}].content`, doc.conditions[i].content);
     }
   }
+  const extendedDoc = doc;
+  if (extendedDoc.definitions) {
+    for (let i = 0; i < extendedDoc.definitions.length; i++) {
+      add(`definitions[${i}].definition`, extendedDoc.definitions[i].definition);
+    }
+  }
+  const coveredReasons = extendedDoc.coveredReasons ?? extendedDoc.covered_reasons;
+  if (coveredReasons) {
+    for (let i = 0; i < coveredReasons.length; i++) {
+      add(`coveredReasons[${i}].content`, coveredReasons[i].content);
+      coveredReasons[i].conditions?.forEach((condition, j) => {
+        add(`coveredReasons[${i}].conditions[${j}]`, condition);
+      });
+    }
+  }
   return entries;
 }
 function parseFormatResponse(response) {
@@ -2249,6 +2450,10 @@ function parseFormatResponse(response) {
   return results;
 }
 function applyFormattedContent(doc, entries, formatted) {
+  const docRecord = doc;
+  if (!docRecord.coveredReasons && docRecord.covered_reasons) {
+    docRecord.coveredReasons = docRecord.covered_reasons;
+  }
   for (const entry of entries) {
     const cleaned = formatted.get(entry.id);
     if (!cleaned) continue;
@@ -2257,6 +2462,14 @@ function applyFormattedContent(doc, entries, formatted) {
     const [, field, idx1, sub1, idx2, sub2] = segments;
     if (!sub1) {
       doc[field] = cleaned;
+    } else if (idx2 && !sub2) {
+      const arr = doc[field];
+      if (arr && arr[Number(idx1)]) {
+        const nested = arr[Number(idx1)][sub1];
+        if (Array.isArray(nested)) {
+          nested[Number(idx2)] = cleaned;
+        }
+      }
     } else if (!sub2) {
       const arr = doc[field];
       if (arr && arr[Number(idx1)]) {
@@ -2321,6 +2534,16 @@ function formatAddress(addr) {
   const parts = [addr.street1, addr.street2, addr.city, addr.state, addr.zip, addr.country].filter(Boolean);
   return parts.join(", ");
 }
+function asRecordArray(value) {
+  return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item)) : [];
+}
+function firstString(item, keys) {
+  for (const key of keys) {
+    const value = item[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return void 0;
+}
 function chunkDocument(doc) {
   const ensureArray = (v) => Array.isArray(v) ? v : [];
   doc = {
@@ -2334,6 +2557,7 @@ function chunkDocument(doc) {
   const chunks = [];
   const docId = doc.id;
   const policyTypesStr = doc.policyTypes?.length ? doc.policyTypes.join(",") : void 0;
+  const extendedDoc = doc;
   function stringMetadata(entries) {
     const base = Object.fromEntries(
       Object.entries(entries).filter(([, value]) => value !== void 0 && value !== null && String(value).length > 0).map(([key, value]) => [key, String(value)])
@@ -2691,6 +2915,82 @@ ${exc.content}`.trim(),
       })
     });
   });
+  asRecordArray(extendedDoc.definitions).forEach((definition, i) => {
+    const term = firstString(definition, ["term", "name", "title"]) ?? `Definition ${i + 1}`;
+    const body = firstString(definition, ["definition", "content", "text", "meaning"]);
+    chunks.push({
+      id: `${docId}:definition:${i}`,
+      documentId: docId,
+      type: "definition",
+      text: [
+        `Definition: ${term}`,
+        body,
+        firstString(definition, ["originalContent", "source"]) ? `Source: ${firstString(definition, ["originalContent", "source"])}` : null
+      ].filter(Boolean).join("\n"),
+      metadata: stringMetadata({
+        term,
+        formNumber: firstString(definition, ["formNumber"]),
+        formTitle: firstString(definition, ["formTitle"]),
+        pageNumber: typeof definition.pageNumber === "number" ? definition.pageNumber : void 0,
+        sectionRef: firstString(definition, ["sectionRef", "sectionTitle"]),
+        documentType: doc.type
+      })
+    });
+  });
+  const coveredReasons = asRecordArray(extendedDoc.coveredReasons ?? extendedDoc.covered_reasons);
+  coveredReasons.forEach((coveredReason, i) => {
+    const title = firstString(coveredReason, ["title", "name", "reason", "peril", "cause"]) ?? `Covered Reason ${i + 1}`;
+    const coverageName = firstString(coveredReason, ["coverageName", "coverage", "coveragePart"]);
+    const reasonNumber = firstString(coveredReason, ["reasonNumber", "number"]);
+    const body = firstString(coveredReason, ["content", "description", "text", "coverageGrant"]);
+    chunks.push({
+      id: `${docId}:covered_reason:${i}`,
+      documentId: docId,
+      type: "covered_reason",
+      text: [
+        coverageName ? `Coverage: ${coverageName}` : null,
+        reasonNumber ? `Reason Number: ${reasonNumber}` : null,
+        `Covered Reason: ${title}`,
+        body,
+        firstString(coveredReason, ["originalContent", "source"]) ? `Source: ${firstString(coveredReason, ["originalContent", "source"])}` : null
+      ].filter(Boolean).join("\n"),
+      metadata: stringMetadata({
+        coverageName,
+        reasonNumber,
+        title,
+        formNumber: firstString(coveredReason, ["formNumber"]),
+        formTitle: firstString(coveredReason, ["formTitle"]),
+        pageNumber: typeof coveredReason.pageNumber === "number" ? coveredReason.pageNumber : void 0,
+        sectionRef: firstString(coveredReason, ["sectionRef", "sectionTitle"]),
+        documentType: doc.type
+      })
+    });
+    const conditions = Array.isArray(coveredReason.conditions) ? coveredReason.conditions.filter((condition) => typeof condition === "string" && condition.trim().length > 0) : [];
+    conditions.forEach((condition, conditionIndex) => {
+      chunks.push({
+        id: `${docId}:covered_reason:${i}:condition:${conditionIndex}`,
+        documentId: docId,
+        type: "covered_reason",
+        text: [
+          coverageName ? `Coverage: ${coverageName}` : null,
+          reasonNumber ? `Reason Number: ${reasonNumber}` : null,
+          `Covered Reason Condition: ${title}`,
+          condition
+        ].filter(Boolean).join("\n"),
+        metadata: stringMetadata({
+          coverageName,
+          reasonNumber,
+          title,
+          conditionIndex,
+          formNumber: firstString(coveredReason, ["formNumber"]),
+          formTitle: firstString(coveredReason, ["formTitle"]),
+          pageNumber: typeof coveredReason.pageNumber === "number" ? coveredReason.pageNumber : void 0,
+          sectionRef: firstString(coveredReason, ["sectionRef", "sectionTitle"]),
+          documentType: doc.type
+        })
+      });
+    });
+  });
   if (doc.declarations) {
     const decl = doc.declarations;
     const declLines = [];
@@ -3236,6 +3536,13 @@ function dedupeByKey(items, keyFn) {
   }
   return merged;
 }
+function normalizeKeyPart(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value).toLowerCase().replace(/&/g, "and").replace(/[^a-z0-9]+/g, "");
+}
+function keyFromParts(...parts) {
+  return parts.map(normalizeKeyPart).join("|");
+}
 function mergeUniqueObjects(existing, incoming, keyFn) {
   return dedupeByKey([...existing, ...incoming], keyFn);
 }
@@ -3264,13 +3571,13 @@ function mergeCoverageLimits(existing, incoming) {
   const merged = mergeShallowPreferPresent(existing, incoming);
   const existingCoverages = Array.isArray(existing.coverages) ? existing.coverages : [];
   const incomingCoverages = Array.isArray(incoming.coverages) ? incoming.coverages : [];
-  const coverageKey = (coverage) => [
-    String(coverage.name ?? "").toLowerCase(),
-    String(coverage.limitType ?? "").toLowerCase(),
-    String(coverage.limit ?? "").toLowerCase(),
-    String(coverage.deductible ?? "").toLowerCase(),
-    String(coverage.formNumber ?? "").toLowerCase()
-  ].join("|");
+  const coverageKey = (coverage) => keyFromParts(
+    coverage.name,
+    coverage.limitType,
+    coverage.limit,
+    coverage.deductible,
+    coverage.formNumber
+  );
   const byKey = /* @__PURE__ */ new Map();
   for (const coverage of [...existingCoverages, ...incomingCoverages]) {
     const key = coverageKey(coverage);
@@ -3284,11 +3591,11 @@ function mergeDeclarations(existing, incoming) {
   const merged = mergeShallowPreferPresent(existing, incoming);
   const existingFields = Array.isArray(existing.fields) ? existing.fields : [];
   const incomingFields = Array.isArray(incoming.fields) ? incoming.fields : [];
-  merged.fields = mergeUniqueObjects(existingFields, incomingFields, (field) => [
-    String(field.field ?? "").toLowerCase(),
-    String(field.value ?? "").toLowerCase(),
-    String(field.section ?? "").toLowerCase()
-  ].join("|"));
+  merged.fields = mergeUniqueObjects(existingFields, incomingFields, (field) => keyFromParts(
+    field.field,
+    field.value,
+    field.section
+  ));
   return merged;
 }
 function mergeArrayPayload(existing, incoming, arrayKey, keyFn) {
@@ -3298,30 +3605,53 @@ function mergeArrayPayload(existing, incoming, arrayKey, keyFn) {
   merged[arrayKey] = mergeUniqueObjects(existingItems, incomingItems, keyFn);
   return merged;
 }
+function readArray(record, ...keys) {
+  for (const key of keys) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+function mergeAliasedArrayPayload(existing, incoming, outputKey, inputKeys, keyFn) {
+  const merged = mergeShallowPreferPresent(existing, incoming);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of [
+    ...readArray(existing, outputKey, ...inputKeys),
+    ...readArray(incoming, outputKey, ...inputKeys)
+  ]) {
+    const key = keyFn(item);
+    const current = byKey.get(key);
+    byKey.set(key, current ? mergeShallowPreferPresent(current, item) : item);
+  }
+  merged[outputKey] = [...byKey.values()];
+  for (const key of inputKeys) {
+    if (key !== outputKey) delete merged[key];
+  }
+  return merged;
+}
 function mergeSupplementary(existing, incoming) {
   const merged = mergeShallowPreferPresent(existing, incoming);
   const mergeContactArray = (arrayKey) => {
     const existingItems = Array.isArray(existing[arrayKey]) ? existing[arrayKey] : [];
     const incomingItems = Array.isArray(incoming[arrayKey]) ? incoming[arrayKey] : [];
-    merged[arrayKey] = mergeUniqueObjects(existingItems, incomingItems, (item) => [
-      String(item.name ?? "").toLowerCase(),
-      String(item.phone ?? "").toLowerCase(),
-      String(item.email ?? "").toLowerCase(),
-      String(item.address ?? "").toLowerCase(),
-      String(item.type ?? "").toLowerCase()
-    ].join("|"));
+    merged[arrayKey] = mergeUniqueObjects(existingItems, incomingItems, (item) => keyFromParts(
+      item.name,
+      item.phone,
+      item.email,
+      item.address,
+      item.type
+    ));
   };
   mergeContactArray("regulatoryContacts");
   mergeContactArray("claimsContacts");
   mergeContactArray("thirdPartyAdministrators");
   const existingFacts = Array.isArray(existing.auxiliaryFacts) ? existing.auxiliaryFacts : [];
   const incomingFacts = Array.isArray(incoming.auxiliaryFacts) ? incoming.auxiliaryFacts : [];
-  merged.auxiliaryFacts = mergeUniqueObjects(existingFacts, incomingFacts, (item) => [
-    String(item.key ?? "").toLowerCase(),
-    String(item.value ?? "").toLowerCase(),
-    String(item.subject ?? "").toLowerCase(),
-    String(item.context ?? "").toLowerCase()
-  ].join("|"));
+  merged.auxiliaryFacts = mergeUniqueObjects(existingFacts, incomingFacts, (item) => keyFromParts(
+    item.key,
+    item.value,
+    item.subject,
+    item.context
+  ));
   return merged;
 }
 function mergeExtractorResult(extractorName, existing, incoming) {
@@ -3342,31 +3672,43 @@ function mergeExtractorResult(extractorName, existing, incoming) {
       return mergeCoverageLimits(current, next);
     case "declarations":
       return mergeDeclarations(current, next);
+    case "definitions":
+      return mergeArrayPayload(current, next, "definitions", (item) => keyFromParts(
+        item.term ?? item.name ?? item.key,
+        item.pageNumber ?? item.pageStart
+      ));
+    case "covered_reasons":
+      return mergeAliasedArrayPayload(current, next, "coveredReasons", ["covered_reasons"], (item) => keyFromParts(
+        item.coverageName ?? item.coverage,
+        item.reasonNumber ?? item.number,
+        item.title ?? item.reason ?? item.name ?? item.cause,
+        item.pageNumber ?? item.pageStart
+      ));
     case "endorsements":
-      return mergeArrayPayload(current, next, "endorsements", (item) => [
-        String(item.formNumber ?? "").toLowerCase(),
-        String(item.title ?? "").toLowerCase(),
-        String(item.pageStart ?? "")
-      ].join("|"));
+      return mergeArrayPayload(current, next, "endorsements", (item) => keyFromParts(
+        item.formNumber,
+        item.title,
+        item.pageStart
+      ));
     case "exclusions":
-      return mergeArrayPayload(current, next, "exclusions", (item) => [
-        String(item.name ?? "").toLowerCase(),
-        String(item.formNumber ?? "").toLowerCase(),
-        String(item.pageNumber ?? "")
-      ].join("|"));
+      return mergeArrayPayload(current, next, "exclusions", (item) => keyFromParts(
+        item.name,
+        item.formNumber,
+        item.pageNumber
+      ));
     case "conditions":
-      return mergeArrayPayload(current, next, "conditions", (item) => [
-        String(item.name ?? "").toLowerCase(),
-        String(item.conditionType ?? "").toLowerCase(),
-        String(item.pageNumber ?? "")
-      ].join("|"));
+      return mergeArrayPayload(current, next, "conditions", (item) => keyFromParts(
+        item.name,
+        item.conditionType,
+        item.pageNumber
+      ));
     case "sections":
-      return mergeArrayPayload(current, next, "sections", (item) => [
-        String(item.title ?? "").toLowerCase(),
-        String(item.type ?? "").toLowerCase(),
-        String(item.pageStart ?? ""),
-        String(item.pageEnd ?? "")
-      ].join("|"));
+      return mergeArrayPayload(current, next, "sections", (item) => keyFromParts(
+        item.title,
+        item.type,
+        item.pageStart,
+        item.pageEnd
+      ));
     default:
       return mergeShallowPreferPresent(current, next);
   }
@@ -4225,6 +4567,8 @@ var PageExtractorSchema = z20.enum([
   "carrier_info",
   "named_insured",
   "coverage_limits",
+  "covered_reasons",
+  "definitions",
   "endorsements",
   "exclusions",
   "conditions",
@@ -4271,6 +4615,8 @@ Available extractors:
 - carrier_info
 - named_insured
 - coverage_limits
+- covered_reasons
+- definitions
 - endorsements
 - exclusions
 - conditions
@@ -4284,6 +4630,8 @@ Rules:
 - Identify the broad section or form context first, then assign focused extractors within that context.
 - Use specific extractors for declarations, schedules, endorsements, exclusions, conditions, premium pages, and loss runs.
 - Use "sections" for pages that contain substantive policy text or mixed content that should still be preserved as raw sections.
+- Use "definitions" for policy-form pages containing defined terms, definitions sections, or term meaning clauses.
+- Use "covered_reasons" for pages listing covered causes of loss, covered reasons, covered perils, named perils, covered events, or covered loss triggers.
 - Avoid assigning broad ranges mentally; decide page by page.
 - A page may map to multiple extractors if it legitimately contains multiple relevant sections.
 - Prefer declarations and schedules for numeric limits/deductibles over later generic form wording.
@@ -4291,6 +4639,7 @@ Rules:
 - Do NOT assign "coverage_limits" for generic policy-form or endorsement text that merely explains how limits, deductibles, waiting periods, or coinsurance work, or that says values are "shown in the declarations", "shown in the schedule", "as stated", or "if applicable".
 - Headings like "Limits of Insurance", "Deductible", "Coinsurance", "Loss Conditions", or "Definitions" inside a policy form usually indicate form language, not declarations or schedules.
 - Continuation pages near the end of a form should stay mapped to "sections" plus "conditions"/"exclusions" when applicable, even if they mention limits or deductibles.
+- Covered causes/reasons and definitions often span a whole form section; tag every substantive page in that section, not just the heading page.
 - When a form inventory entry identifies a page range as a specific form type (e.g., endorsement, coverage, application), use that classification to guide your extractor choice. Do not assign "coverage_limits" to pages the inventory identifies as endorsement or condition/exclusion forms unless the page contains actual schedule values.
 - Do not tag a page with "exclusions" or "conditions" if it only contains a table of contents, page-number reference, running header/footer, or a heading that points to another page without substantive wording.
 - If a page appears to be part of a larger exclusion, conditions, or endorsement section within the same form, keep the assignment consistent across nearby pages in that section rather than isolating a single page fragment.
@@ -4359,9 +4708,13 @@ Mark the extraction as NOT complete if any of these are true:
 - required fields are missing
 - extracted values are generic placeholders like "shown in declarations", "per schedule", "if applicable", "as stated"
 - coverage limits or deductibles appear to come from generic form language instead of declaration/schedule-specific values
+- definitions pages were mapped but no definition records or definition-type sections were extracted
+- covered causes/reasons pages were mapped but no covered reason, covered peril, covered cause, or matching section records were extracted
 - page assignments suggest declaration, schedule, endorsement, exclusion, or condition pages were not actually extracted with the matching focused extractor
 - a focused extractor exists but returned too little substance for the relevant pages
 
+When reviewing CURRENT EXTRACTION SUMMARY, compare the page-map counts to extracted counts. For definitions and covered_reasons, missing extraction should produce a quality issue and a narrow follow-up task over the mapped page range.
+
 Return JSON:
 {
   "complete": boolean,
@@ -5005,6 +5358,107 @@ For auxiliaryFacts:
 Return JSON only.`;
 }
 
+// src/prompts/extractors/definitions.ts
+import { z as z34 } from "zod";
+var DefinitionsSchema = z34.object({
+  definitions: z34.array(
+    z34.object({
+      term: z34.string().describe("Defined term exactly as shown in the document"),
+      definition: z34.string().describe("Full verbatim definition text, preserving original wording"),
+      pageNumber: z34.number().optional().describe("Original document page number"),
+      formNumber: z34.string().optional().describe("Form number where this definition appears"),
+      formTitle: z34.string().optional().describe("Form title where this definition appears"),
+      sectionRef: z34.string().optional().describe("Definition section heading or subsection reference"),
+      originalContent: z34.string().optional().describe("Short verbatim source snippet containing the term and definition")
+    })
+  ).describe("All substantive insurance definitions found in the document")
+});
+function buildDefinitionsPrompt() {
+  return `You are an expert insurance document analyst. Extract ALL substantive defined terms from this document. Preserve original wording verbatim.
+
+For EACH definition, extract:
+- term: defined term exactly as shown \u2014 REQUIRED
+- definition: full verbatim definition text including all included subparts \u2014 REQUIRED
+- pageNumber: original document page number where the definition appears
+- formNumber: form number where the definition appears, if shown
+- formTitle: form title where the definition appears, if shown
+- sectionRef: heading such as "Definitions", "Words and Phrases Defined", or coverage-specific definition section
+- originalContent: short verbatim source snippet containing the term and definition
+
+Focus on:
+- Terms in sections titled Definitions, Words and Phrases Defined, Glossary, or similar
+- Coverage-specific defined terms embedded in insuring agreements, endorsements, exclusions, or conditions
+- Multi-part definitions with numbered, lettered, or bulleted clauses
+- Definitions that affect coverage triggers, covered property, insured status, exclusions, limits, or duties
+
+Critical rules:
+- Preserve the original content. Do not paraphrase content.
+- Keep all subparts of a definition together in one item when they define the same term.
+- Ignore table-of-contents entries, running headers/footers, indexes, and cross-references that do not include substantive definition text.
+- Do not emit generic headings like "Definitions" as a term unless the page defines an actual term.
+- Always include pageNumber when the definition appears on a specific page in the supplied document chunk.
+- Use definition as the canonical full text. Do not return a separate content field.
+
+Return JSON only.`;
+}
+
+// src/prompts/extractors/covered-reasons.ts
+import { z as z35 } from "zod";
+var CoveredReasonsSchema = z35.object({
+  coveredReasons: z35.array(
+    z35.object({
+      coverageName: z35.string().describe("Coverage, coverage part, or form this covered reason belongs to"),
+      reasonNumber: z35.string().optional().describe("Source number or letter for the covered reason, if shown"),
+      title: z35.string().optional().describe("Covered reason title, peril, cause of loss, trigger, or short name"),
+      content: z35.string().describe("Full verbatim covered-reason or insuring-agreement text"),
+      conditions: z35.array(z35.string()).optional().describe("Conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason"),
+      exceptions: z35.array(z35.string()).optional().describe("Exceptions or limitations attached to this covered reason"),
+      appliesTo: z35.array(z35.string()).optional().describe("Covered property, persons, autos, locations, operations, or coverage parts this reason applies to"),
+      pageNumber: z35.number().optional().describe("Original document page number"),
+      formNumber: z35.string().optional().describe("Form number where this covered reason appears"),
+      formTitle: z35.string().optional().describe("Form title where this covered reason appears"),
+      sectionRef: z35.string().optional().describe("Section heading where this covered reason appears"),
+      originalContent: z35.string().optional().describe("Short verbatim source snippet used for this covered reason")
+    })
+  ).describe("Covered causes, perils, triggers, or reasons that affirmatively grant coverage")
+});
+function buildCoveredReasonsPrompt() {
+  return `You are an expert insurance document analyst. Extract ALL covered reasons from this document. Preserve original wording verbatim.
+
+A covered reason is affirmative coverage language explaining why, when, or for what cause the insurer will pay. This may be called a covered peril, covered cause of loss, accident, occurrence, loss trigger, additional coverage, expense, or insuring agreement grant.
+
+For EACH covered reason, extract:
+- coverageName: coverage, coverage part, or form this covered reason belongs to \u2014 REQUIRED
+- reasonNumber: source number or letter for the covered reason, if shown
+- title: covered peril, cause of loss, trigger, or short name
+- content: full verbatim covered-reason or insuring-agreement text \u2014 REQUIRED
+- conditions: conditions, timing rules, documentation requirements, or prerequisites attached to this covered reason
+- exceptions: exceptions or limitations attached to this covered reason
+- appliesTo: covered property, persons, autos, locations, operations, or coverage parts this reason applies to
+- pageNumber: original document page number where this covered reason appears
+- formNumber: form number where this covered reason appears, if shown
+- formTitle: form title where this covered reason appears, if shown
+- sectionRef: heading where this covered reason appears
+- originalContent: short verbatim source snippet used for this covered reason
+
+Focus on:
+- Named perils and covered causes of loss
+- Insuring agreement grants and coverage triggers
+- Additional coverages and coverage extensions that state when payment applies
+- Personal lines phrases such as fire, lightning, windstorm, hail, theft, collision, comprehensive, or accidental direct physical loss
+- Commercial lines phrases such as bodily injury, property damage, personal and advertising injury, employee dishonesty, computer fraud, equipment breakdown, or professional services acts
+
+Critical rules:
+- Preserve the original content. Do not paraphrase content.
+- Extract affirmative coverage grants, not exclusions, conditions, or declarations-only limit rows.
+- Do not emit a covered reason from a table-of-contents entry, running header/footer, or reference that only points elsewhere.
+- If a covered reason includes exceptions or limitations in the same clause, keep them in content and also list them in exceptions when they can be separated cleanly.
+- Always include pageNumber when the covered reason appears on a specific page in the supplied document chunk.
+- Preserve coverage grouping. Do not merge separate coverage parts into one generic list.
+
+Return JSON only.`;
+}
+
 // src/prompts/extractors/index.ts
 var EXTRACTORS = {
   carrier_info: { buildPrompt: buildCarrierInfoPrompt, schema: CarrierInfoSchema, maxTokens: 2048 },
@@ -5017,28 +5471,30 @@ var EXTRACTORS = {
   declarations: { buildPrompt: buildDeclarationsPrompt, schema: DeclarationsExtractSchema, maxTokens: 8192 },
   loss_history: { buildPrompt: buildLossHistoryPrompt, schema: LossHistorySchema, maxTokens: 4096 },
   sections: { buildPrompt: buildSectionsPrompt, schema: SectionsSchema, maxTokens: 8192 },
-  supplementary: { buildPrompt: buildSupplementaryPrompt, schema: SupplementarySchema, maxTokens: 2048 }
+  supplementary: { buildPrompt: buildSupplementaryPrompt, schema: SupplementarySchema, maxTokens: 2048 },
+  definitions: { buildPrompt: buildDefinitionsPrompt, schema: DefinitionsSchema, maxTokens: 8192 },
+  covered_reasons: { buildPrompt: buildCoveredReasonsPrompt, schema: CoveredReasonsSchema, maxTokens: 8192 }
 };
 function getExtractor(name) {
   return EXTRACTORS[name];
 }
 
 // src/extraction/resolve-referential.ts
-import { z as z35 } from "zod";
+import { z as z37 } from "zod";
 
 // src/prompts/extractors/referential-lookup.ts
-import { z as z34 } from "zod";
-var ReferentialLookupSchema = z34.object({
-  resolvedCoverages: z34.array(
-    z34.object({
-      coverageName: z34.string().describe("The coverage name that was referenced"),
-      resolvedLimit: z34.string().optional().describe("The concrete limit value found, if any"),
+import { z as z36 } from "zod";
+var ReferentialLookupSchema = z36.object({
+  resolvedCoverages: z36.array(
+    z36.object({
+      coverageName: z36.string().describe("The coverage name that was referenced"),
+      resolvedLimit: z36.string().optional().describe("The concrete limit value found, if any"),
       resolvedLimitValueType: CoverageValueTypeSchema.optional(),
-      resolvedDeductible: z34.string().optional().describe("The concrete deductible value found, if any"),
+      resolvedDeductible: z36.string().optional().describe("The concrete deductible value found, if any"),
       resolvedDeductibleValueType: CoverageValueTypeSchema.optional(),
-      pageNumber: z34.number().optional().describe("Page where the resolved value was found"),
-      originalContent: z34.string().optional().describe("Verbatim source text for the resolved value"),
-      confidence: z34.enum(["high", "medium", "low"]).describe("Confidence in the resolution")
+      pageNumber: z36.number().optional().describe("Page where the resolved value was found"),
+      originalContent: z36.string().optional().describe("Verbatim source text for the resolved value"),
+      confidence: z36.enum(["high", "medium", "low"]).describe("Confidence in the resolution")
     })
   )
 });
@@ -5097,9 +5553,9 @@ function parseReferenceTarget(text) {
   if (/if applicable/i.test(normalized)) return void 0;
   return void 0;
 }
-var PageLocationSchema = z35.object({
-  startPage: z35.number(),
-  endPage: z35.number()
+var PageLocationSchema = z37.object({
+  startPage: z37.number(),
+  endPage: z37.number()
 });
 async function findReferencedPages(params) {
   const {
@@ -5419,6 +5875,32 @@ function buildExtractionReviewReport(params) {
   const exclusions = memory.get("exclusions")?.exclusions ?? [];
   const conditions = memory.get("conditions")?.conditions ?? [];
   const sections = memory.get("sections")?.sections ?? [];
+  const definitionsResult = memory.get("definitions");
+  const coveredReasonsResult = memory.get("covered_reasons");
+  const definitions = Array.isArray(definitionsResult?.definitions) ? definitionsResult.definitions : sections.filter((section) => section.type === "definition");
+  const coveredReasons = Array.isArray(coveredReasonsResult?.coveredReasons) ? coveredReasonsResult.coveredReasons : Array.isArray(coveredReasonsResult?.covered_reasons) ? coveredReasonsResult.covered_reasons : sections.filter((section) => {
+    const title = String(section.title ?? "").toLowerCase();
+    const type = String(section.type ?? "").toLowerCase();
+    return type === "covered_reason" || title.includes("covered cause") || title.includes("covered reason") || title.includes("covered peril");
+  });
+  const mappedDefinitions = params.pageAssignments.some((assignment) => assignment.extractorNames.includes("definitions"));
+  const mappedCoveredReasons = params.pageAssignments.some((assignment) => assignment.extractorNames.includes("covered_reasons"));
+  if (mappedDefinitions && definitions.length === 0) {
+    deterministicIssues.push({
+      code: "definitions_mapped_but_empty",
+      severity: "warning",
+      message: "Page map assigned definitions extraction, but no definition records were extracted.",
+      extractorName: "definitions"
+    });
+  }
+  if (mappedCoveredReasons && coveredReasons.length === 0) {
+    deterministicIssues.push({
+      code: "covered_reasons_mapped_but_empty",
+      severity: "warning",
+      message: "Page map assigned covered reasons extraction, but no covered reason records were extracted.",
+      extractorName: "covered_reasons"
+    });
+  }
   for (const form of extractedFormInventory) {
     addFormEntry(
       inventory,
@@ -5616,6 +6098,67 @@ function buildExtractionReviewReport(params) {
       });
     }
   }
+  for (const definition of definitions) {
+    const term = typeof definition.term === "string" ? definition.term : typeof definition.title === "string" ? definition.title : "unknown";
+    const content = typeof definition.definition === "string" ? definition.definition : typeof definition.content === "string" ? definition.content : "";
+    if (!content.trim()) {
+      deterministicIssues.push({
+        code: "definition_missing_content",
+        severity: "warning",
+        message: `Definition "${term}" is missing definition text.`,
+        extractorName: "definitions",
+        formNumber: normalizeFormNumber(definition.formNumber),
+        pageNumber: typeof definition.pageNumber === "number" ? definition.pageNumber : typeof definition.pageStart === "number" ? definition.pageStart : void 0,
+        itemName: term
+      });
+    }
+    if (typeof definition.pageNumber !== "number" && typeof definition.pageStart !== "number") {
+      deterministicIssues.push({
+        code: "definition_missing_page_number",
+        severity: "warning",
+        message: `Definition "${term}" is missing page provenance.`,
+        extractorName: "definitions",
+        formNumber: normalizeFormNumber(definition.formNumber),
+        itemName: term
+      });
+    }
+  }
+  for (const coveredReason of coveredReasons) {
+    const itemName = typeof coveredReason.name === "string" ? coveredReason.name : typeof coveredReason.reason === "string" ? coveredReason.reason : typeof coveredReason.title === "string" ? coveredReason.title : "unknown";
+    const content = typeof coveredReason.content === "string" ? coveredReason.content : typeof coveredReason.description === "string" ? coveredReason.description : "";
+    if (!content.trim()) {
+      deterministicIssues.push({
+        code: "covered_reason_missing_content",
+        severity: "warning",
+        message: `Covered reason "${itemName}" is missing substantive text.`,
+        extractorName: "covered_reasons",
+        formNumber: normalizeFormNumber(coveredReason.formNumber),
+        pageNumber: typeof coveredReason.pageNumber === "number" ? coveredReason.pageNumber : typeof coveredReason.pageStart === "number" ? coveredReason.pageStart : void 0,
+        itemName
+      });
+    }
+    if (typeof coveredReason.pageNumber !== "number" && typeof coveredReason.pageStart !== "number") {
+      deterministicIssues.push({
+        code: "covered_reason_missing_page_number",
+        severity: "warning",
+        message: `Covered reason "${itemName}" is missing page provenance.`,
+        extractorName: "covered_reasons",
+        formNumber: normalizeFormNumber(coveredReason.formNumber),
+        itemName
+      });
+    }
+    if (looksReferential2(content) || looksReferential2(coveredReason.reason)) {
+      deterministicIssues.push({
+        code: "covered_reason_referential_value",
+        severity: "warning",
+        message: `Covered reason "${itemName}" contains referential language instead of the extracted covered cause wording.`,
+        extractorName: "covered_reasons",
+        formNumber: normalizeFormNumber(coveredReason.formNumber),
+        pageNumber: typeof coveredReason.pageNumber === "number" ? coveredReason.pageNumber : typeof coveredReason.pageStart === "number" ? coveredReason.pageStart : void 0,
+        itemName
+      });
+    }
+  }
   for (const section of sections) {
     if (typeof section.content === "string" && section.content.trim().length < 120 && typeof section.pageStart === "number" && (!("pageEnd" in section) || section.pageEnd === section.pageStart || section.pageEnd === void 0)) {
       deterministicIssues.push({
@@ -5638,6 +6181,8 @@ function buildExtractionReviewReport(params) {
   const artifacts = [
     { kind: "form_inventory", label: "Form Inventory", itemCount: formInventory.length },
     { kind: "page_map", label: "Page Map", itemCount: params.pageAssignments.length },
+    { kind: "definitions", label: "Definitions", itemCount: definitions.length },
+    { kind: "covered_reasons", label: "Covered Reasons", itemCount: coveredReasons.length },
     { kind: "referential_resolution", label: "Referential Resolution", itemCount: coverages.filter((c) => c.limitValueType === "referential" || c.limitValueType === "as_stated" || c.deductibleValueType === "referential" || c.deductibleValueType === "as_stated").length }
   ];
   const qualityGateStatus = evaluateQualityGate({
@@ -5705,6 +6250,15 @@ function createExtractor(config) {
     const exclusionResult = memory.get("exclusions");
     const conditionResult = memory.get("conditions");
     const sectionResult = memory.get("sections");
+    const definitionsResult = memory.get("definitions");
+    const coveredReasonsResult = memory.get("covered_reasons");
+    const sections = Array.isArray(sectionResult?.sections) ? sectionResult.sections : [];
+    const definitionCount = Array.isArray(definitionsResult?.definitions) ? definitionsResult.definitions.length : sections.filter((section) => section.type === "definition").length;
+    const coveredReasonCount = Array.isArray(coveredReasonsResult?.coveredReasons) ? coveredReasonsResult.coveredReasons.length : Array.isArray(coveredReasonsResult?.covered_reasons) ? coveredReasonsResult.covered_reasons.length : sections.filter((section) => {
+      const title = String(section.title ?? "").toLowerCase();
+      const type = String(section.type ?? "").toLowerCase();
+      return type === "covered_reason" || title.includes("covered cause") || title.includes("covered reason") || title.includes("covered peril");
+    }).length;
     const coverageSummary = Array.isArray(coverageResult?.coverages) ? coverageResult.coverages.slice(0, 12).map((coverage) => ({
       name: coverage.name,
       limit: coverage.limit,
@@ -5719,7 +6273,9 @@ function createExtractor(config) {
       endorsementCount: Array.isArray(endorsementResult?.endorsements) ? endorsementResult.endorsements.length : 0,
       exclusionCount: Array.isArray(exclusionResult?.exclusions) ? exclusionResult.exclusions.length : 0,
       conditionCount: Array.isArray(conditionResult?.conditions) ? conditionResult.conditions.length : 0,
-      sectionCount: Array.isArray(sectionResult?.sections) ? sectionResult.sections.length : 0
+      definitionCount,
+      coveredReasonCount,
+      sectionCount: sections.length
     }, null, 2);
   }
   function buildAlreadyExtractedSummary(memory) {
@@ -5762,7 +6318,7 @@ function createExtractor(config) {
       }
     }
     if (extractorPages.size === 0) return "No page assignments available.";
-    return [...extractorPages.entries()].map(([extractorName, pages]) => `${extractorName}: pages ${pages.join(", ")}`).join("\n");
+    return [...extractorPages.entries()].map(([extractorName, pages]) => `${extractorName}: ${pages.length} page(s), pages ${pages.join(", ")}`).join("\n");
   }
   function normalizePageAssignments(pageAssignments, formInventory) {
     const pageFormTypes = /* @__PURE__ */ new Map();
@@ -5852,7 +6408,7 @@ function createExtractor(config) {
         extractorPages.set("sections", [...extractorPages.get("sections") ?? [], page]);
       }
     }
-    const contextualExtractors = /* @__PURE__ */ new Set(["conditions", "exclusions", "endorsements"]);
+    const contextualExtractors = /* @__PURE__ */ new Set(["conditions", "covered_reasons", "definitions", "exclusions", "endorsements"]);
     const contextualForms = (formInventory?.forms ?? []).filter(
       (form) => form.pageStart != null && (form.pageEnd ?? form.pageStart) != null
     );
@@ -6068,7 +6624,7 @@ function createExtractor(config) {
       const extractorResults = await Promise.all(
         tasks.map(
           (task) => limit(async () => {
-            const ext = getExtractor(task.extractorName);
+            const ext = getExtractor(task.extractorName) ?? (task.extractorName === "definitions" || task.extractorName === "covered_reasons" ? getExtractor("sections") : void 0);
             if (!ext) {
               await log?.(`Unknown extractor: ${task.extractorName}, skipping`);
               return null;
@@ -6199,7 +6755,7 @@ function createExtractor(config) {
         const followUpResults = await Promise.all(
           reviewResponse.object.additionalTasks.map(
             (task) => limit(async () => {
-              const ext = getExtractor(task.extractorName);
+              const ext = getExtractor(task.extractorName) ?? (task.extractorName === "definitions" || task.extractorName === "covered_reasons" ? getExtractor("sections") : void 0);
               if (!ext) return null;
               try {
                 const result = await runExtractor({
@@ -6539,8 +7095,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-import { z as z36 } from "zod";
-var FieldTypeSchema = z36.enum([
+import { z as z38 } from "zod";
+var FieldTypeSchema = z38.enum([
   "text",
   "numeric",
   "currency",
@@ -6549,131 +7105,131 @@ var FieldTypeSchema = z36.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = z36.object({
-  id: z36.string(),
-  label: z36.string(),
-  section: z36.string(),
+var ApplicationFieldSchema = z38.object({
+  id: z38.string(),
+  label: z38.string(),
+  section: z38.string(),
   fieldType: FieldTypeSchema,
-  required: z36.boolean(),
-  options: z36.array(z36.string()).optional(),
-  columns: z36.array(z36.string()).optional(),
-  requiresExplanationIfYes: z36.boolean().optional(),
-  condition: z36.object({
-    dependsOn: z36.string(),
-    whenValue: z36.string()
+  required: z38.boolean(),
+  options: z38.array(z38.string()).optional(),
+  columns: z38.array(z38.string()).optional(),
+  requiresExplanationIfYes: z38.boolean().optional(),
+  condition: z38.object({
+    dependsOn: z38.string(),
+    whenValue: z38.string()
   }).optional(),
-  value: z36.string().optional(),
-  source: z36.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: z36.enum(["confirmed", "high", "medium", "low"]).optional()
-});
-var ApplicationClassifyResultSchema = z36.object({
-  isApplication: z36.boolean(),
-  confidence: z36.number().min(0).max(1),
-  applicationType: z36.string().nullable()
-});
-var FieldExtractionResultSchema = z36.object({
-  fields: z36.array(ApplicationFieldSchema)
-});
-var AutoFillMatchSchema = z36.object({
-  fieldId: z36.string(),
-  value: z36.string(),
-  confidence: z36.enum(["confirmed"]),
-  contextKey: z36.string()
-});
-var AutoFillResultSchema = z36.object({
-  matches: z36.array(AutoFillMatchSchema)
-});
-var QuestionBatchResultSchema = z36.object({
-  batches: z36.array(z36.array(z36.string()).describe("Array of field IDs in this batch"))
-});
-var LookupRequestSchema = z36.object({
-  type: z36.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: z36.string(),
-  url: z36.string().optional(),
-  targetFieldIds: z36.array(z36.string())
-});
-var ReplyIntentSchema = z36.object({
-  primaryIntent: z36.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: z36.boolean(),
-  questionText: z36.string().optional(),
-  questionFieldIds: z36.array(z36.string()).optional(),
-  lookupRequests: z36.array(LookupRequestSchema).optional()
-});
-var ParsedAnswerSchema = z36.object({
-  fieldId: z36.string(),
-  value: z36.string(),
-  explanation: z36.string().optional()
-});
-var AnswerParsingResultSchema = z36.object({
-  answers: z36.array(ParsedAnswerSchema),
-  unanswered: z36.array(z36.string()).describe("Field IDs that were not answered")
-});
-var LookupFillSchema = z36.object({
-  fieldId: z36.string(),
-  value: z36.string(),
-  source: z36.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
-});
-var LookupFillResultSchema = z36.object({
-  fills: z36.array(LookupFillSchema),
-  unfillable: z36.array(z36.string()),
-  explanation: z36.string().optional()
-});
-var FlatPdfPlacementSchema = z36.object({
-  fieldId: z36.string(),
-  page: z36.number(),
-  x: z36.number().describe("Percentage from left edge (0-100)"),
-  y: z36.number().describe("Percentage from top edge (0-100)"),
-  text: z36.string(),
-  fontSize: z36.number().optional(),
-  isCheckmark: z36.boolean().optional()
-});
-var AcroFormMappingSchema = z36.object({
-  fieldId: z36.string(),
-  acroFormName: z36.string(),
-  value: z36.string()
-});
-var QualityGateStatusSchema = z36.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = z36.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = z36.object({
-  code: z36.string(),
+  value: z38.string().optional(),
+  source: z38.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: z38.enum(["confirmed", "high", "medium", "low"]).optional()
+});
+var ApplicationClassifyResultSchema = z38.object({
+  isApplication: z38.boolean(),
+  confidence: z38.number().min(0).max(1),
+  applicationType: z38.string().nullable()
+});
+var FieldExtractionResultSchema = z38.object({
+  fields: z38.array(ApplicationFieldSchema)
+});
+var AutoFillMatchSchema = z38.object({
+  fieldId: z38.string(),
+  value: z38.string(),
+  confidence: z38.enum(["confirmed"]),
+  contextKey: z38.string()
+});
+var AutoFillResultSchema = z38.object({
+  matches: z38.array(AutoFillMatchSchema)
+});
+var QuestionBatchResultSchema = z38.object({
+  batches: z38.array(z38.array(z38.string()).describe("Array of field IDs in this batch"))
+});
+var LookupRequestSchema = z38.object({
+  type: z38.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: z38.string(),
+  url: z38.string().optional(),
+  targetFieldIds: z38.array(z38.string())
+});
+var ReplyIntentSchema = z38.object({
+  primaryIntent: z38.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: z38.boolean(),
+  questionText: z38.string().optional(),
+  questionFieldIds: z38.array(z38.string()).optional(),
+  lookupRequests: z38.array(LookupRequestSchema).optional()
+});
+var ParsedAnswerSchema = z38.object({
+  fieldId: z38.string(),
+  value: z38.string(),
+  explanation: z38.string().optional()
+});
+var AnswerParsingResultSchema = z38.object({
+  answers: z38.array(ParsedAnswerSchema),
+  unanswered: z38.array(z38.string()).describe("Field IDs that were not answered")
+});
+var LookupFillSchema = z38.object({
+  fieldId: z38.string(),
+  value: z38.string(),
+  source: z38.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+});
+var LookupFillResultSchema = z38.object({
+  fills: z38.array(LookupFillSchema),
+  unfillable: z38.array(z38.string()),
+  explanation: z38.string().optional()
+});
+var FlatPdfPlacementSchema = z38.object({
+  fieldId: z38.string(),
+  page: z38.number(),
+  x: z38.number().describe("Percentage from left edge (0-100)"),
+  y: z38.number().describe("Percentage from top edge (0-100)"),
+  text: z38.string(),
+  fontSize: z38.number().optional(),
+  isCheckmark: z38.boolean().optional()
+});
+var AcroFormMappingSchema = z38.object({
+  fieldId: z38.string(),
+  acroFormName: z38.string(),
+  value: z38.string()
+});
+var QualityGateStatusSchema = z38.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = z38.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = z38.object({
+  code: z38.string(),
   severity: QualitySeveritySchema,
-  message: z36.string(),
-  fieldId: z36.string().optional()
+  message: z38.string(),
+  fieldId: z38.string().optional()
 });
-var ApplicationQualityRoundSchema = z36.object({
-  round: z36.number(),
-  kind: z36.string(),
+var ApplicationQualityRoundSchema = z38.object({
+  round: z38.number(),
+  kind: z38.string(),
   status: QualityGateStatusSchema,
-  summary: z36.string().optional()
+  summary: z38.string().optional()
 });
-var ApplicationQualityArtifactSchema = z36.object({
-  kind: z36.string(),
-  label: z36.string().optional(),
-  itemCount: z36.number().optional()
+var ApplicationQualityArtifactSchema = z38.object({
+  kind: z38.string(),
+  label: z38.string().optional(),
+  itemCount: z38.number().optional()
 });
-var ApplicationEmailReviewSchema = z36.object({
-  issues: z36.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = z38.object({
+  issues: z38.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = z36.object({
-  issues: z36.array(ApplicationQualityIssueSchema),
-  rounds: z36.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: z36.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = z38.object({
+  issues: z38.array(ApplicationQualityIssueSchema),
+  rounds: z38.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: z38.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationStateSchema = z36.object({
-  id: z36.string(),
-  pdfBase64: z36.string().optional().describe("Original PDF, omitted after extraction"),
-  title: z36.string().optional(),
-  applicationType: z36.string().nullable().optional(),
-  fields: z36.array(ApplicationFieldSchema),
-  batches: z36.array(z36.array(z36.string())).optional(),
-  currentBatchIndex: z36.number().default(0),
+var ApplicationStateSchema = z38.object({
+  id: z38.string(),
+  pdfBase64: z38.string().optional().describe("Original PDF, omitted after extraction"),
+  title: z38.string().optional(),
+  applicationType: z38.string().nullable().optional(),
+  fields: z38.array(ApplicationFieldSchema),
+  batches: z38.array(z38.array(z38.string())).optional(),
+  currentBatchIndex: z38.number().default(0),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: z36.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: z36.number(),
-  updatedAt: z36.number()
+  status: z38.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: z38.number(),
+  updatedAt: z38.number()
 });
 
 // src/application/agents/classifier.ts
@@ -7779,7 +8335,7 @@ INSTRUCTIONS:
    - If the user's attachment already contains critical facts, still request chunk/document lookup when policy or quote details should be cross-checked against stored records
 
 CHUNK TYPES (for chunkTypes filter):
-carrier_info, named_insured, coverage, endorsement, exclusion, condition, section, declaration, loss_history, premium, supplementary
+carrier_info, named_insured, coverage, covered_reason, definition, endorsement, exclusion, condition, section, declaration, loss_history, premium, supplementary
 
 Respond with the structured classification.`;
 }
@@ -7810,91 +8366,91 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-import { z as z37 } from "zod";
-var QueryIntentSchema = z37.enum([
+import { z as z39 } from "zod";
+var QueryIntentSchema = z39.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = z37.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = z37.object({
-  id: z37.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = z39.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = z39.object({
+  id: z39.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: z37.string().optional().describe("Original filename or user-facing label"),
-  mimeType: z37.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: z37.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: z37.string().optional().describe("Plain-text attachment content when available"),
-  description: z37.string().optional().describe("Caller-provided description of the attachment")
-});
-var SubQuestionSchema = z37.object({
-  question: z37.string().describe("Atomic sub-question to retrieve and answer independently"),
+  name: z39.string().optional().describe("Original filename or user-facing label"),
+  mimeType: z39.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: z39.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: z39.string().optional().describe("Plain-text attachment content when available"),
+  description: z39.string().optional().describe("Caller-provided description of the attachment")
+});
+var SubQuestionSchema = z39.object({
+  question: z39.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: z37.array(z37.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: z37.object({
-    type: z37.enum(["policy", "quote"]).optional(),
-    carrier: z37.string().optional(),
-    insuredName: z37.string().optional(),
-    policyNumber: z37.string().optional(),
-    quoteNumber: z37.string().optional(),
-    policyTypes: z37.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
+  chunkTypes: z39.array(z39.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: z39.object({
+    type: z39.enum(["policy", "quote"]).optional(),
+    carrier: z39.string().optional(),
+    insuredName: z39.string().optional(),
+    policyNumber: z39.string().optional(),
+    quoteNumber: z39.string().optional(),
+    policyTypes: z39.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = z37.object({
+var QueryClassifyResultSchema = z39.object({
   intent: QueryIntentSchema,
-  subQuestions: z37.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: z37.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: z37.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: z37.boolean().describe("Whether conversation history is relevant")
-});
-var EvidenceItemSchema = z37.object({
-  source: z37.enum(["chunk", "document", "conversation", "attachment"]),
-  chunkId: z37.string().optional(),
-  documentId: z37.string().optional(),
-  turnId: z37.string().optional(),
-  attachmentId: z37.string().optional(),
-  text: z37.string().describe("Text excerpt from the source"),
-  relevance: z37.number().min(0).max(1),
-  metadata: z37.array(z37.object({ key: z37.string(), value: z37.string() })).optional()
-});
-var AttachmentInterpretationSchema = z37.object({
-  summary: z37.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: z37.array(z37.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: z37.array(z37.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: z37.number().min(0).max(1)
-});
-var RetrievalResultSchema = z37.object({
-  subQuestion: z37.string(),
-  evidence: z37.array(EvidenceItemSchema)
-});
-var CitationSchema = z37.object({
-  index: z37.number().describe("Citation number [1], [2], etc."),
-  chunkId: z37.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: z37.string(),
-  documentType: z37.enum(["policy", "quote"]).optional(),
-  field: z37.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: z37.string().describe("Exact text from source that supports the claim"),
-  relevance: z37.number().min(0).max(1)
-});
-var SubAnswerSchema = z37.object({
-  subQuestion: z37.string(),
-  answer: z37.string(),
-  citations: z37.array(CitationSchema),
-  confidence: z37.number().min(0).max(1),
-  needsMoreContext: z37.boolean().describe("True if evidence was insufficient to answer fully")
-});
-var VerifyResultSchema = z37.object({
-  approved: z37.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: z37.array(z37.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: z37.array(z37.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
-});
-var QueryResultSchema = z37.object({
-  answer: z37.string(),
-  citations: z37.array(CitationSchema),
+  subQuestions: z39.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: z39.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: z39.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: z39.boolean().describe("Whether conversation history is relevant")
+});
+var EvidenceItemSchema = z39.object({
+  source: z39.enum(["chunk", "document", "conversation", "attachment"]),
+  chunkId: z39.string().optional(),
+  documentId: z39.string().optional(),
+  turnId: z39.string().optional(),
+  attachmentId: z39.string().optional(),
+  text: z39.string().describe("Text excerpt from the source"),
+  relevance: z39.number().min(0).max(1),
+  metadata: z39.array(z39.object({ key: z39.string(), value: z39.string() })).optional()
+});
+var AttachmentInterpretationSchema = z39.object({
+  summary: z39.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: z39.array(z39.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: z39.array(z39.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: z39.number().min(0).max(1)
+});
+var RetrievalResultSchema = z39.object({
+  subQuestion: z39.string(),
+  evidence: z39.array(EvidenceItemSchema)
+});
+var CitationSchema = z39.object({
+  index: z39.number().describe("Citation number [1], [2], etc."),
+  chunkId: z39.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: z39.string(),
+  documentType: z39.enum(["policy", "quote"]).optional(),
+  field: z39.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: z39.string().describe("Exact text from source that supports the claim"),
+  relevance: z39.number().min(0).max(1)
+});
+var SubAnswerSchema = z39.object({
+  subQuestion: z39.string(),
+  answer: z39.string(),
+  citations: z39.array(CitationSchema),
+  confidence: z39.number().min(0).max(1),
+  needsMoreContext: z39.boolean().describe("True if evidence was insufficient to answer fully")
+});
+var VerifyResultSchema = z39.object({
+  approved: z39.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: z39.array(z39.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: z39.array(z39.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+});
+var QueryResultSchema = z39.object({
+  answer: z39.string(),
+  citations: z39.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: z37.number().min(0).max(1),
-  followUp: z37.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: z39.number().min(0).max(1),
+  followUp: z39.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -8899,6 +9455,7 @@ export {
   CoverageSchema,
   CoverageTriggerSchema,
   CoverageValueTypeSchema,
+  CoveredReasonSchema,
   CrimeDeclarationsSchema,
   CyberDeclarationsSchema,
   DEDUCTIBLE_TYPES,
@@ -8911,6 +9468,7 @@ export {
   DeductibleScheduleSchema,
   DeductibleTypeSchema,
   DefenseCostTreatmentSchema,
+  DefinitionSchema,
   DocumentTypeSchema,
   DriverRecordSchema,
   DwellingDetailsSchema,