@claritylabs/cl-sdk 3.2.10 → 3.2.12

package/dist/index.js

@@ -182,6 +182,7 @@ __export(src_exports, {
   POLICY_SECTION_TYPES: () => POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES: () => POLICY_TERM_TYPES,
   POLICY_TYPES: () => POLICY_TYPES,
+  POLICY_TYPES_FROM_COVERAGES_WARNING: () => POLICY_TYPES_FROM_COVERAGES_WARNING,
   ParsedAnswerSchema: () => ParsedAnswerSchema,
   PaymentInstallmentSchema: () => PaymentInstallmentSchema,
   PaymentPlanSchema: () => PaymentPlanSchema,
@@ -337,6 +338,7 @@ __export(src_exports, {
   getNextApplicationQuestions: () => getNextApplicationQuestions,
   getPdfPageCount: () => getPdfPageCount,
   getTemplate: () => getTemplate,
+  inferPolicyTypesFromOperationalCoverages: () => inferPolicyTypesFromOperationalCoverages,
   isDoclingExtractionInput: () => isDoclingExtractionInput,
   isFileReference: () => isFileReference,
   mergeQuestionAnswers: () => mergeQuestionAnswers,
@@ -345,6 +347,7 @@ __export(src_exports, {
   normalizeDoclingDocument: () => normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths: () => normalizeDocumentSourceTreePaths,
   normalizeForMatch: () => normalizeForMatch,
+  normalizeOperationalPolicyTypes: () => normalizeOperationalPolicyTypes,
   normalizeSourceSpans: () => normalizeSourceSpans,
   orderSourceEvidence: () => orderSourceEvidence,
   overlayTextOnPdf: () => overlayTextOnPdf,
@@ -355,6 +358,7 @@ __export(src_exports, {
   processReply: () => processReply,
   proposeContextWrites: () => proposeContextWrites,
   resolveModelBudget: () => resolveModelBudget,
+  resolveOperationalProfilePolicyTypes: () => resolveOperationalProfilePolicyTypes,
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
   scoreCaseProposal: () => scoreCaseProposal,
@@ -710,6 +714,10 @@ var PolicyTypeSchema = import_zod2.z.enum([
   "watercraft",
   "recreational_vehicle",
   "farm_ranch",
+  "life",
+  "critical_illness",
+  "disability",
+  "long_term_care",
   "pet",
   "travel",
   "identity_theft",
@@ -2515,6 +2523,179 @@ var PolicyOperationalProfileSchema = import_zod20.z.object({
   warnings: import_zod20.z.array(import_zod20.z.string()).default([])
 });
 
+// src/source/policy-types.ts
+var POLICY_TYPE_KEYS = new Set(POLICY_TYPES);
+var POLICY_TYPE_ALIASES = {
+  "general liability": "general_liability",
+  "commercial general liability": "general_liability",
+  cgl: "general_liability",
+  "commercial property": "commercial_property",
+  property: "property",
+  "property insurance": "commercial_property",
+  "commercial auto": "commercial_auto",
+  "commercial automobile": "commercial_auto",
+  "business auto": "commercial_auto",
+  "business automobile": "commercial_auto",
+  "auto physical damage": "commercial_auto",
+  "automobile physical damage": "commercial_auto",
+  "hired non owned auto": "non_owned_auto",
+  "hired non-owned auto": "non_owned_auto",
+  "non owned auto": "non_owned_auto",
+  "non-owned auto": "non_owned_auto",
+  "workers comp": "workers_comp",
+  "workers compensation": "workers_comp",
+  "workers' compensation": "workers_comp",
+  umbrella: "umbrella",
+  "excess liability": "excess_liability",
+  "professional liability": "professional_liability",
+  "errors and omissions": "professional_liability",
+  "e&o": "professional_liability",
+  cyber: "cyber",
+  "cyber liability": "cyber",
+  "network security": "cyber",
+  "privacy liability": "cyber",
+  epli: "epli",
+  "employment practices liability": "epli",
+  "directors and officers": "directors_officers",
+  "directors & officers": "directors_officers",
+  "d&o": "directors_officers",
+  "fiduciary liability insurance": "fiduciary_liability",
+  "crime insurance": "crime_fidelity",
+  "fidelity bond": "crime_fidelity",
+  "inland marine insurance": "inland_marine",
+  "motor truck cargo": "inland_marine",
+  "motor truck cargo legal liability": "inland_marine",
+  "builders risk insurance": "builders_risk",
+  "pollution liability": "environmental",
+  "premises pollution liability": "environmental",
+  "environmental liability": "environmental",
+  "ocean marine insurance": "ocean_marine",
+  "surety bond": "surety",
+  "product liability insurance": "product_liability",
+  "life insurance": "life",
+  "permanent life": "life",
+  "term life": "life",
+  "whole life": "life",
+  "universal life": "life",
+  "critical illness": "critical_illness",
+  "critical illness insurance": "critical_illness",
+  "disability insurance": "disability",
+  "long term care": "long_term_care",
+  "long-term care": "long_term_care"
+};
+var POLICY_TYPE_TEXT_PATTERNS = [
+  { type: "general_liability", pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
+  { type: "commercial_property", pattern: /\bcommercial\s+property\b|\bproperty\s+insurance\b/i },
+  { type: "commercial_auto", pattern: /\bcommercial\s+auto(?:mobile)?\b|\bbusiness\s+auto(?:mobile)?\b|\bauto(?:mobile)?\s+physical\s+damage\b/i },
+  { type: "non_owned_auto", pattern: /\b(?:hired\s+(?:and\s+)?)?non[-\s]?owned\s+auto\b/i },
+  { type: "workers_comp", pattern: /\bworkers['’]?\s+comp(?:ensation)?\b/i },
+  { type: "umbrella", pattern: /\bcommercial\s+umbrella\b|\bumbrella\s+liability\b/i },
+  { type: "excess_liability", pattern: /\bexcess\s+liability\b/i },
+  { type: "professional_liability", pattern: /\bprofessional\s+liability\b|\berrors?\s*(?:and|&)\s*omissions?\b|\be&o\b/i },
+  { type: "cyber", pattern: /\bcyber\b|\bnetwork\s+security\b|\bprivacy\s+liability\b/i },
+  { type: "epli", pattern: /\bemployment\s+practices?\s+liability\b|\bepli\b/i },
+  { type: "directors_officers", pattern: /\bdirectors?\s*(?:and|&)\s*officers?\b|\bd&o\b/i },
+  { type: "fiduciary_liability", pattern: /\bfiduciary\s+liability\b/i },
+  { type: "crime_fidelity", pattern: /\bcrime\b|\bfidelity\b/i },
+  { type: "inland_marine", pattern: /\binland\s+marine\b|\bmotor\s+truck\s+cargo\b|\bcargo\s+legal\s+liability\b/i },
+  { type: "builders_risk", pattern: /\bbuilders?\s+risk\b/i },
+  { type: "environmental", pattern: /\bpollution\s+liability\b|\benvironmental\s+liability\b/i },
+  { type: "ocean_marine", pattern: /\bocean\s+marine\b/i },
+  { type: "surety", pattern: /\bsurety\b/i },
+  { type: "product_liability", pattern: /\bproduct\s+liability\b|\bproducts?\s+completed\s+operations\b/i },
+  { type: "bop", pattern: /\bbusiness\s*owners?\s+policy\b|\bbop\b/i },
+  { type: "homeowners_ho3", pattern: /\bhomeowners?\s*(?:ho[-\s]?3)?\b/i },
+  { type: "homeowners_ho5", pattern: /\bho[-\s]?5\b/i },
+  { type: "renters_ho4", pattern: /\brenters?\b|\bho[-\s]?4\b/i },
+  { type: "condo_ho6", pattern: /\bcondo(?:minium)?\b|\bho[-\s]?6\b/i },
+  { type: "dwelling_fire", pattern: /\bdwelling\s+fire\b/i },
+  { type: "personal_auto", pattern: /\bpersonal\s+auto\b/i },
+  { type: "personal_umbrella", pattern: /\bpersonal\s+umbrella\b/i },
+  { type: "flood_private", pattern: /\bflood\b/i },
+  { type: "earthquake", pattern: /\bearthquake\b/i },
+  { type: "personal_inland_marine", pattern: /\bpersonal\s+(?:articles|inland\s+marine)\b/i },
+  { type: "watercraft", pattern: /\bwatercraft\b|\bboat\s+insurance\b/i },
+  { type: "recreational_vehicle", pattern: /\brecreational\s+vehicle\b|\brv\s+insurance\b/i },
+  { type: "farm_ranch", pattern: /\bfarm\b|\branch\b/i },
+  { type: "life", pattern: /\blife\s+insurance\b|\bterm\s+life\b|\bwhole\s+life\b|\buniversal\s+life\b/i },
+  { type: "critical_illness", pattern: /\bcritical\s+illness\b/i },
+  { type: "disability", pattern: /\bdisability\s+insurance\b|\btotal\s+disability\b/i },
+  { type: "long_term_care", pattern: /\blong[-\s]?term\s+care\b/i },
+  { type: "pet", pattern: /\bpet\s+insurance\b/i },
+  { type: "travel", pattern: /\btravel\s+insurance\b/i },
+  { type: "identity_theft", pattern: /\bidentity\s+theft\b/i },
+  { type: "title", pattern: /\btitle\s+insurance\b/i }
+];
+var POLICY_TYPES_FROM_COVERAGES_WARNING = "Policy types augmented from extracted coverage labels.";
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeOperationalPolicyTypes(values) {
+  const types = Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
+  const controlled = types.map((type) => type.trim().toLowerCase().replace(/\s+/g, " ")).map((type) => POLICY_TYPE_ALIASES[type] ?? type.replace(/[\s-]+/g, "_")).filter((type) => POLICY_TYPE_KEYS.has(type));
+  const unique = [...new Set(controlled)].slice(0, 6);
+  return unique.length ? unique : ["other"];
+}
+function hasSpecificPolicyType(types) {
+  return types.some((type) => type !== "other");
+}
+function policyTypesFromText(value) {
+  const text = normalizeWhitespace(value ?? "");
+  if (!text) return [];
+  const aliasType = POLICY_TYPE_ALIASES[text.toLowerCase()];
+  if (aliasType && POLICY_TYPE_KEYS.has(aliasType)) return [aliasType];
+  return POLICY_TYPE_TEXT_PATTERNS.filter(({ pattern }) => pattern.test(text)).map(({ type }) => type).filter((type) => POLICY_TYPE_KEYS.has(type));
+}
+function inferPolicyTypesFromOperationalCoverages(coverages) {
+  const inferred = [];
+  for (const coverage of coverages) {
+    const limits = coverage.limits ?? [];
+    const text = [
+      coverage.coverageCode,
+      coverage.formNumber,
+      coverage.name,
+      ...limits.flatMap((term) => [term.appliesTo, term.label])
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    for (const value of text) {
+      for (const type of policyTypesFromText(value)) {
+        if (!inferred.includes(type)) inferred.push(type);
+      }
+    }
+  }
+  return inferred.slice(0, 6);
+}
+function mergePolicyTypes(base, additions) {
+  const merged = [
+    ...base.filter((type) => type !== "other"),
+    ...additions.filter((type) => type !== "other")
+  ];
+  const unique = [...new Set(merged)].slice(0, 6);
+  return unique.length ? unique : base;
+}
+function resolveOperationalProfilePolicyTypes(params) {
+  const inferred = inferPolicyTypesFromOperationalCoverages(params.coverages ?? []);
+  const controlled = normalizeOperationalPolicyTypes(params.profileTypes);
+  if (hasSpecificPolicyType(controlled)) {
+    const policyTypes = mergePolicyTypes(controlled, inferred);
+    return {
+      policyTypes,
+      source: policyTypes.length > controlled.filter((type) => type !== "other").length ? "profile_augmented" : "profile"
+    };
+  }
+  const existingControlled = normalizeOperationalPolicyTypes(params.existingTypes);
+  if (hasSpecificPolicyType(existingControlled)) {
+    const policyTypes = mergePolicyTypes(existingControlled, inferred);
+    return {
+      policyTypes,
+      source: policyTypes.length > existingControlled.filter((type) => type !== "other").length ? "existing_augmented" : "existing"
+    };
+  }
+  if (inferred.length > 0) {
+    return { policyTypes: inferred, source: "inferred" };
+  }
+  return { policyTypes: controlled, source: "profile" };
+}
+
 // src/source/ids.ts
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -2581,14 +2762,14 @@ function orderSourceEvidence(evidence) {
 }
 
 // src/source/extraction.ts
-function normalizeWhitespace(value) {
+function normalizeWhitespace2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function sanitizeIdPart(value) {
   return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
 }
 function buildSourceSpan(input, localIndex = 0) {
-  const text = normalizeWhitespace(input.text);
+  const text = normalizeWhitespace2(input.text);
   const textHash = sourceSpanTextHash(text);
   const pagePart = input.pageStart ?? "na";
   const id = [
@@ -2623,7 +2804,7 @@ function buildSourceSpan(input, localIndex = 0) {
   });
 }
 function buildPageSourceSpans(pages) {
-  return pages.filter((page) => normalizeWhitespace(page.text).length > 0).map(
+  return pages.filter((page) => normalizeWhitespace2(page.text).length > 0).map(
     (page, index) => buildSourceSpan(
       {
         documentId: page.documentId,
@@ -2674,7 +2855,7 @@ function buildSectionSourceSpans(pages, options = {}) {
 function buildTextSourceSpans(input, options = {}) {
   const maxChars = options.maxChars ?? 4e3;
   const overlapChars = Math.min(options.overlapChars ?? 0, Math.max(0, maxChars - 1));
-  const text = normalizeWhitespace(input.text);
+  const text = normalizeWhitespace2(input.text);
   if (!text) return [];
   const spans = [];
   let cursor = 0;
@@ -2749,7 +2930,7 @@ function spanPage(span) {
 }
 function normalizeSourceSpanText(span) {
   const unit = sourceUnit(span);
-  const text = normalizeWhitespace(span.text);
+  const text = normalizeWhitespace2(span.text);
   if (!text) return void 0;
   if (isDiscardableBoilerplate(text, unit)) return void 0;
   const cleanedText = cleanBoilerplateLines(text);
@@ -2761,7 +2942,7 @@ function normalizeSourceSpanText(span) {
   });
 }
 function isDiscardableBoilerplate(text, unit) {
-  const cleaned = normalizeWhitespace(text.replace(/\bColumn\s+\d+:\s*/gi, ""));
+  const cleaned = normalizeWhitespace2(text.replace(/\bColumn\s+\d+:\s*/gi, ""));
   if (/^SPECIMEN POLICY\s+[-—]\s+FOR TESTING ONLY$/i.test(cleaned)) return true;
   if (/^Page\s+\d+\s+of\s+\d+$/i.test(cleaned)) return true;
   if (/^[A-Z]{2,}(?:-[A-Z0-9]{2,})+\s+\d{2}\s+\d{2}$/i.test(cleaned)) return true;
@@ -2770,24 +2951,24 @@ function isDiscardableBoilerplate(text, unit) {
   return false;
 }
 function isBoilerplateLine(line) {
-  const cleaned = normalizeWhitespace(line.replace(/\bColumn\s+\d+:\s*/gi, ""));
+  const cleaned = normalizeWhitespace2(line.replace(/\bColumn\s+\d+:\s*/gi, ""));
   return isDiscardableBoilerplate(cleaned) || /^THIS IS A CLAIMS-MADE AND REPORTED POLICY\.? PLEASE READ IT CAREFULLY\.?$/i.test(cleaned);
 }
 function removedBoilerplateLines(text) {
-  return text.split(/\s{2,}|\r?\n/).map(normalizeWhitespace).filter((line) => line && isBoilerplateLine(line));
+  return text.split(/\s{2,}|\r?\n/).map(normalizeWhitespace2).filter((line) => line && isBoilerplateLine(line));
 }
 function cleanBoilerplateLines(text) {
   const withoutInlineBoilerplate = text.replace(/\b(?:Column\s+\d+:\s*)?[A-Z]{2,}(?:-[A-Z0-9]{2,})+\s+\d{2}\s+\d{2}\s+(?:\|\s*)?(?:Column\s+\d+:\s*)?Page\s+\d+\s+of\s+\d+\b/gi, " ").replace(/\bSPECIMEN POLICY\s+[-—]\s+FOR TESTING ONLY\b/gi, " ").replace(/\bPage\s+\d+\s+of\s+\d+\b/gi, " ");
   const lines = withoutInlineBoilerplate.split(/\r?\n/);
-  const filtered = lines.map(normalizeWhitespace).filter((line) => line && !isBoilerplateLine(line));
-  return normalizeWhitespace(filtered.join(" "));
+  const filtered = lines.map(normalizeWhitespace2).filter((line) => line && !isBoilerplateLine(line));
+  return normalizeWhitespace2(filtered.join(" "));
 }
 function shouldMergeTextSpan(left, right) {
   if (sourceUnit(left) !== "text" || sourceUnit(right) !== "text") return false;
   if (spanPage(left) !== spanPage(right)) return false;
   if (left.metadata?.elementType === "title" || right.metadata?.elementType === "title") return false;
-  const leftText = normalizeWhitespace(left.text);
-  const rightText = normalizeWhitespace(right.text);
+  const leftText = normalizeWhitespace2(left.text);
+  const rightText = normalizeWhitespace2(right.text);
   if (!leftText || !rightText) return false;
   if (/[:.;!?)]$/.test(leftText)) return false;
   if (/^(?:[A-Z][A-Z0-9 &/(),.-]{8,}|Item\s+\d+|Section\s+\d+|Part\s+[A-Z]\b)/.test(rightText)) return false;
@@ -2808,7 +2989,7 @@ function mergeTextRuns(spans) {
   return result;
 }
 function mergeTextSpanPair(left, right) {
-  const text = normalizeWhitespace(`${left.text} ${right.text}`);
+  const text = normalizeWhitespace2(`${left.text} ${right.text}`);
   const merged = retextSpan(left, text, {
     mergedSourceSpanIds: [left.metadata?.mergedSourceSpanIds, left.id, right.id, right.metadata?.mergedSourceSpanIds].filter(Boolean).join(","),
     sourceSpanNormalization: "merged_text_run"
@@ -2860,7 +3041,7 @@ function splitPageIntoSections(text, headingPattern, minSectionChars) {
       if (current) sections.push(current);
       const suffix = match[1]?.trim();
       current = {
-        title: normalizeWhitespace(suffix ? `${line}` : line).slice(0, 120),
+        title: normalizeWhitespace2(suffix ? `${line}` : line).slice(0, 120),
         lines: [line]
       };
       continue;
@@ -2870,7 +3051,7 @@ function splitPageIntoSections(text, headingPattern, minSectionChars) {
   if (current) sections.push(current);
   return sections.map((section) => ({
     title: section.title,
-    text: normalizeWhitespace(section.lines.join("\n"))
+    text: normalizeWhitespace2(section.lines.join("\n"))
   })).filter((section) => section.text.length >= minSectionChars);
 }
 function inferFormNumber(text) {
@@ -2971,14 +3152,14 @@ function matchesFilters(span, filters) {
 }
 
 // src/source/tree.ts
-function normalizeWhitespace2(value) {
+function normalizeWhitespace3(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function sanitizeIdPart2(value) {
   return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
 }
 function truncate(value, maxChars) {
-  const text = normalizeWhitespace2(value);
+  const text = normalizeWhitespace3(value);
   return text.length > maxChars ? `${text.slice(0, maxChars).trimEnd()}...` : text;
 }
 function pageStart(span) {
@@ -3072,7 +3253,7 @@ function isTitleContentNode(node) {
   if (node.kind !== "text") return false;
   const isMarkedTitle = metadataString(node.metadata, "elementType") === "title" || metadataString(node.metadata, "sourceUnit") === "title";
   if (!isMarkedTitle) return false;
-  const text = normalizeWhitespace2(node.textExcerpt ?? node.title);
+  const text = normalizeWhitespace3(node.textExcerpt ?? node.title);
   if (!text || text.length > 140) return false;
   const words = text.split(/\s+/);
   if (words.length > 14) return false;
@@ -3747,12 +3928,12 @@ function shouldFailQualityGate(mode, status) {
 var import_zod22 = require("zod");
 
 // src/source/operational-profile.ts
-function normalizeWhitespace3(value) {
+function normalizeWhitespace4(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function cleanValue(value) {
   if (!value) return void 0;
-  return normalizeWhitespace3(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
+  return normalizeWhitespace4(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
 }
 var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
   "each_claim_limit",
@@ -3834,6 +4015,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
       ...keepIds(record.sourceSpanIds, validSpanIds),
       ...limits.flatMap((term) => term.sourceSpanIds)
     ])];
+    if (!name || sourceNodeIds2.length === 0 && sourceSpanIds2.length === 0) return void 0;
     return {
       name,
       coverageCode: typeof record.coverageCode === "string" ? cleanValue(record.coverageCode) : void 0,
@@ -3848,7 +4030,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
       sourceNodeIds: sourceNodeIds2,
       sourceSpanIds: sourceSpanIds2
     };
-  }).filter((coverage) => coverage.name && (coverage.sourceNodeIds.length > 0 || coverage.sourceSpanIds.length > 0)) : base.coverages;
+  }).filter((coverage) => Boolean(coverage)) : base.coverages;
   const sourceBackedParty = (role, value) => value ? {
     role,
     name: value.normalizedValue ?? value.value,
@@ -3916,10 +4098,18 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     ...base.warnings,
     ...Array.isArray(candidate.warnings) ? candidate.warnings.filter((warning) => typeof warning === "string" && warning.trim().length > 0) : []
   ];
+  const resolvedPolicyTypes = resolveOperationalProfilePolicyTypes({
+    profileTypes: candidate.policyTypes,
+    existingTypes: base.policyTypes,
+    coverages
+  });
+  if (resolvedPolicyTypes.source === "profile_augmented" || resolvedPolicyTypes.source === "existing_augmented" || resolvedPolicyTypes.source === "inferred") {
+    warnings.push(POLICY_TYPES_FROM_COVERAGES_WARNING);
+  }
   return PolicyOperationalProfileSchema.parse({
     ...base,
     documentType: candidate.documentType === "policy" ? "policy" : base.documentType,
-    policyTypes: Array.isArray(candidate.policyTypes) && candidate.policyTypes.length > 0 ? candidate.policyTypes : base.policyTypes,
+    policyTypes: resolvedPolicyTypes.policyTypes,
     policyNumber,
     namedInsured,
     insurer,
@@ -4149,9 +4339,11 @@ Task:
 Projection defects to look for:
 - Generic labels such as "Column 3" that should be renamed from nearby row/header evidence.
 - Declaration or section headers projected as coverage names when the row evidence is actually a specific coverage, sub-limit, deductible, retention, retroactive date, or premium.
+- Premium-only, tax-only, fee-only, rating, exposure, reporting-value, or payment-plan rows projected as coverage rows.
 - Dangling continuation punctuation such as a trailing "/" copied into values.
 - Item references such as "shown in Item 7" or bare item numbers treated as money amounts.
 - Policy wording, exclusions, or unsupported prose copied into operational limit/deductible fields.
+- Premium, MGA Fee, taxes, stamping fees, total premium, total due, reporting values, or exposure annual rate used as a coverage limit.
 - Header/value splits where "Limit of Liability", "Deductible", "Retroactive Date", "Aggregate", "Each Claim", or similar terms are attached to the wrong coverage row.
 - Repeated schedule headings projected as separate coverages when they only introduce the next coverage group.
 
@@ -4161,7 +4353,8 @@ Rules:
 - Use sourceNodeIds and sourceSpanIds only from the provided source nodes or from the existing candidate entry.
 - Prefer dropping a malformed fact over speculative rewriting.
 - Keep a coverage when it is a real operational coverage/benefit even if only one term needs cleanup.
-- Never drop a declaration or schedule coverage row that names a coverage and states policy-specific amounts, dates, deductibles, retentions, premiums, or coverage terms. Repair its terms instead.
+- Drop a coverage row when its only facts are premium, tax, fee, rating, reporting-value, exposure, or payment-plan facts and it has no source-backed limit, deductible, retention, retroactive date, sublimit, or benefit term.
+- Never drop a declaration or schedule coverage row that names a coverage and states policy-specific limits, dates, deductibles, retentions, sublimits, or benefit terms. Repair its terms instead.
 - When changing a term's semantic meaning, set kind to the corrected normalized term kind.
 - Do not add new coverage rows or new terms; this pass cleans the existing projection.
 - If one existing term combines multiple real limit bases, such as "Each Claim / Aggregate", keep the combined term unless another existing term already represents the other basis. Do not relabel it to only one basis and lose information.
@@ -5502,8 +5695,10 @@ Rules:
 - When citing an evidence entry, copy its sourceSpanId into the returned sourceSpanIds array.
 - If a value is not directly supported, omit it.
 - Prefer declarations, schedules, premium tables, and endorsement schedules over generic policy wording.
+- For effective, expiration, retroactive, and other date fields, return a normalized YYYY-MM-DD value when the source date is unambiguous, including month-name dates such as "20 Feb 2026". Do not emit fragmented date text such as "20 2 2026".
 - For broker/producer, extract the agency or company legal name, not the license role, credential, or type. In a block like "Bayshore Insurance Brokers, LLC" followed by "Surplus Lines Broker - CA License No. ...", broker.value must be "Bayshore Insurance Brokers, LLC"; the surplus-lines role and license number are not the broker name.
 - On declarations pages, treat "Item N" labels as section boundaries. Use Item 6 or equivalent coverage-schedule rows for coverage limits, deductibles, aggregate terms, and retroactive dates; do not merge Item 7 premium, Item 8 ERP, Item 9 producer, or Item 10 forms into Item 6 coverage facts.
+- Premium, tax, fee, payment-plan, rating, exposure, and reporting-value schedules are billing evidence, not coverage schedules. Extract the total policy premium into premium when supported, but do not create coverages[] entries from premium-only or fee-only rows, and never use Total Premium, MGA Fee, tax, stamping fee, reporting values, or exposure annual rate as a coverage limit.
 - A coverage schedule row's coverage name should come from the "Coverage Part" or equivalent row label. Limit, deductible, aggregate, sublimit, retention, and retroactive-date values belong as nested terms under that coverage, not in the coverage title.
 - If a coverage schedule continues onto the next page before the next item marker, include the continuation rows in the same coverage or declaration item.
 - If one schedule row or continuation row states the same amount with multiple bases, such as "$1,000,000 Each Claim / Aggregate", return separate limit terms for each basis using the same value instead of one combined "Each Claim / Aggregate" term.
@@ -5553,7 +5748,10 @@ var NORMALIZED_COMPATIBILITY_FIELDS = /* @__PURE__ */ new Set([
   "policyNumber",
   "namedInsured",
   "insurer",
-  "broker"
+  "broker",
+  "effectiveDate",
+  "expirationDate",
+  "retroactiveDate"
 ]);
 function valueOf(profile, key) {
   const value = profile[key];
@@ -12981,6 +13179,7 @@ function getTemplate(policyType) {
   POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES,
   POLICY_TYPES,
+  POLICY_TYPES_FROM_COVERAGES_WARNING,
   ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
@@ -13136,6 +13335,7 @@ function getTemplate(policyType) {
   getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
+  inferPolicyTypesFromOperationalCoverages,
   isDoclingExtractionInput,
   isFileReference,
   mergeQuestionAnswers,
@@ -13144,6 +13344,7 @@ function getTemplate(policyType) {
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
+  normalizeOperationalPolicyTypes,
   normalizeSourceSpans,
   orderSourceEvidence,
   overlayTextOnPdf,
@@ -13154,6 +13355,7 @@ function getTemplate(policyType) {
   processReply,
   proposeContextWrites,
   resolveModelBudget,
+  resolveOperationalProfilePolicyTypes,
   safeGenerateObject,
   sanitizeNulls,
   scoreCaseProposal,